Module Mod.Src

Module sources.

A small abstraction to represent OCaml modules to compile and find out about source dependencies via Tool.ocamldep.

XXX. This abstraction supports having .ml and .mli in different directories. The current reality though prevents us from that.

Modules

module Deps : sig ... end

Source dependencies.

type t

The type for OCaml module sources, represents a module to compile in a build directory.

val v : mod_name:Name.t -> opaque:bool -> mli:B00_std.Fpath.t option -> mli_deps:Name.Set.t -> ml:B00_std.Fpath.t option -> ml_deps:Name.Set.t -> build_dir:B00_std.Fpath.t -> t

v ~mod_name ~opaque ~mli ~mli_deps ~ml ~ml_deps ~build_dir is a module whose name is name, interface file is mli (if any), interface file module dependencies is mli_deps, implementation is ml (if any) and implementation file module dependencies ml_deps. The module is expected to be built in build_dir. For opaque see opaque.

val mod_name : t -> Name.t

mod_name m is m's name.

val opaque : t -> bool

opaque m indicates whether the module should be treated as opaque for compilation. See the -opaque option in the OCaml manual.

val mli : t -> B00_std.Fpath.t option

mli m is m's interface file (if any).

val mli_deps : t -> Name.Set.t

mli_deps m are m's interface file dependencies.

val ml : t -> B00_std.Fpath.t option

ml m is m's implementation file (if any).

val ml_deps : t -> Name.Set.t

ml_deps m are m's implementation file dependencies.

Constructing file paths

val build_dir : t -> B00_std.Fpath.t

build_dir m is the build directory for the module.

val built_file : t -> ext:string -> B00_std.Fpath.t

built_file m ~ext is a file for module m with extension ext in directory build_dir m.

val cmi_file : t -> B00_std.Fpath.t

cmi_file m is built_file m ext:".cmi".

val cmo_file : t -> B00_std.Fpath.t option

cmo_file m is built_file m ext:".cmo" if ml is Some _.

val cmx_file : t -> B00_std.Fpath.t option

cmx_file m is built_file m ext:".cmx" if ml is Some _.

val impl_file : code:Conf.code -> t -> B00_std.Fpath.t option

impl_file ~code m is cmx_file or cmo_file according to code.

val as_intf_dep_files : ?⁠init:B00_std.Fpath.t list -> t -> B00_std.Fpath.t list

as_intf_dep_files ~init m adds to init (defaults to []) the files that are read by the OCaml compiler if module source m is compiled in build_dir and used as an interface compilation dependency.

val as_impl_dep_files : ?⁠init:B00_std.Fpath.t list -> code:Conf.code -> t -> B00_std.Fpath.t list

as_impl_dep_files ~init ~code m adds to init (defaults to []) the files that are read by the OCaml compiler if module source m is compiled in build_dir and used an implementation file dependency for code code.

Module name maps

val map_of_srcs : B00.Memo.t -> build_dir:B00_std.Fpath.t -> srcs:B00_std.Fpath.t list -> src_deps:Name.Set.t B00_std.Fpath.Map.t -> t Name.Map.t

of_srcs m ~srcs ~src_deps determines source modules values to be built in build_dir (mapped by their names) given sources srcs and their dependencies src_deps (e.g. obtainted via Deps.read. If there's more than one mli or ml file for a given module name a warning is notified on m and a single one is kept.

val sort : ?⁠stable:t list -> deps:(t -> Name.Set.t) -> t Name.Map.t -> t list

sort ~stable ~deps srcs sorts srcs in deps dependency order respecting elements mentioned in stable (if any).

val find : Name.Set.t -> t Name.Map.t -> t list * Name.Set.t

find names srcs is (mods, remain) with mods the names of names found in srcs and remain those that are not.

Convenience

val map_of_files : ?⁠only_mlis:bool -> B00.Memo.t -> build_dir:B00_std.Fpath.t -> src_root:B00_std.Fpath.t -> srcs:B00_fexts.map -> t Name.Map.t B00_std.Fut.t

map_of_files m ~only_mlis ~build_dir ~src_root ~srcs looks for .ml (if only_mlis is false, default) and .mli files in srcs and determines sorted module sources. src_root indicates a root for the sources in srcs and build_dir are used to write the Deps sort.

val pp : t B00_std.Fmt.t

pp formats a module source