sig
module String :
sig
external length : string -> int = "%string_length"
external get : string -> int -> char = "%string_safe_get"
external set : string -> int -> char -> unit = "%string_safe_set"
external create : int -> string = "caml_create_string"
val make : int -> char -> string
val copy : string -> string
val sub : string -> int -> int -> string
val fill : string -> int -> int -> char -> unit
val blit : string -> int -> string -> int -> int -> unit
val concat : string -> string list -> string
val iter : (char -> unit) -> string -> unit
val iteri : (int -> char -> unit) -> string -> unit
val map : (char -> char) -> string -> string
val trim : string -> string
val escaped : string -> string
val index : string -> char -> int
val rindex : string -> char -> int
val index_from : string -> int -> char -> int
val rindex_from : string -> int -> char -> int
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
type t = string
val compare : t -> t -> int
external unsafe_get : string -> int -> char = "%string_unsafe_get"
external unsafe_set : string -> int -> char -> unit
= "%string_unsafe_set"
external unsafe_blit : string -> int -> string -> int -> int -> unit
= "caml_blit_string" "noalloc"
external unsafe_fill : string -> int -> int -> char -> unit
= "caml_fill_string" "noalloc"
val split : sep:string -> string -> string list
val rsplit : sep:string -> string -> string list
val cut : sep:string -> string -> (string * string) option
val rcut : sep:string -> string -> (string * string) option
val slice : ?start:int -> ?stop:int -> string -> string
val tokens : string -> string list
val uniquify : string list -> string list
module Set :
sig
type elt = string
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : string list -> t
end
val make_unique_in :
?suff:string -> Assemblage.String.Set.t -> string -> string option
module Map :
sig
type key = string
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val dom : 'a t -> Assemblage.String.Set.t
end
end
module Fmt :
sig
type 'a formatter = Format.formatter -> 'a -> unit
val pp :
Format.formatter ->
('a, Format.formatter, unit) Pervasives.format -> 'a
val rpp :
('a, Format.formatter, unit) Pervasives.format ->
Format.formatter -> 'a
val nop : 'a Assemblage.Fmt.formatter
val pp_cut : unit Assemblage.Fmt.formatter
val pp_sp : unit Assemblage.Fmt.formatter
val pp_str : string Assemblage.Fmt.formatter
val pp_int : int Assemblage.Fmt.formatter
val pp_bool : bool Assemblage.Fmt.formatter
val pp_larrow : unit Assemblage.Fmt.formatter
val pp_rarrow : unit Assemblage.Fmt.formatter
val pp_opt :
?pp_none:unit Assemblage.Fmt.formatter ->
'a Assemblage.Fmt.formatter -> 'a option Assemblage.Fmt.formatter
val pp_list :
?pp_sep:unit Assemblage.Fmt.formatter ->
'a Assemblage.Fmt.formatter -> 'a list Assemblage.Fmt.formatter
val pp_text : string Assemblage.Fmt.formatter
val pp_lines : string Assemblage.Fmt.formatter
val pp_doomed : string Assemblage.Fmt.formatter
val pp_if_utf8 :
'a Assemblage.Fmt.formatter ->
'a Assemblage.Fmt.formatter -> 'a Assemblage.Fmt.formatter
type style =
[ `Black
| `Blue
| `Bold
| `Cyan
| `Green
| `Magenta
| `None
| `Red
| `Underline
| `White
| `Yellow ]
val pp_styled :
Assemblage.Fmt.style ->
'a Assemblage.Fmt.formatter -> 'a Assemblage.Fmt.formatter
val pp_styled_str :
Assemblage.Fmt.style -> string Assemblage.Fmt.formatter
end
module Path :
sig
type filename = string
type rel
type abs
type t
val root : Assemblage.Path.t
val empty : Assemblage.Path.t
val dash : Assemblage.Path.t
val add : Assemblage.Path.t -> string -> Assemblage.Path.t
val concat :
Assemblage.Path.t -> Assemblage.Path.rel -> Assemblage.Path.t
val ( / ) : Assemblage.Path.t -> string -> Assemblage.Path.t
val ( // ) :
Assemblage.Path.t -> Assemblage.Path.rel -> Assemblage.Path.t
val file : Assemblage.Path.filename -> Assemblage.Path.t
val base : string -> Assemblage.Path.t
val basename : Assemblage.Path.t -> string
val dirname : Assemblage.Path.t -> Assemblage.Path.t
val rem_prefix :
Assemblage.Path.t -> Assemblage.Path.t -> Assemblage.Path.rel option
val find_prefix :
Assemblage.Path.t -> Assemblage.Path.t -> Assemblage.Path.t option
val is_root : Assemblage.Path.t -> bool
val is_empty : Assemblage.Path.t -> bool
val is_dash : Assemblage.Path.t -> bool
val is_rel : Assemblage.Path.t -> bool
val is_abs : Assemblage.Path.t -> bool
val is_prefix : Assemblage.Path.t -> Assemblage.Path.t -> bool
val equal : Assemblage.Path.t -> Assemblage.Path.t -> bool
val compare : Assemblage.Path.t -> Assemblage.Path.t -> int
val to_rel : Assemblage.Path.t -> Assemblage.Path.rel option
val of_rel : Assemblage.Path.rel -> Assemblage.Path.t
val to_abs : Assemblage.Path.t -> Assemblage.Path.abs option
val of_abs : Assemblage.Path.abs -> Assemblage.Path.t
val to_segs :
Assemblage.Path.t -> [ `Abs of string list | `Rel of string list ]
val of_segs :
[ `Abs of string list | `Rel of string list ] -> Assemblage.Path.t
val to_string : Assemblage.Path.t -> string
val of_string : string -> Assemblage.Path.t
val quote : Assemblage.Path.t -> string
val pp : Format.formatter -> Assemblage.Path.t -> unit
type ext =
[ `A
| `Byte
| `C
| `Cma
| `Cmi
| `Cmo
| `Cmt
| `Cmti
| `Cmx
| `Cmxa
| `Cmxs
| `Css
| `Dll
| `Exe
| `Ext of string
| `Gif
| `H
| `Html
| `Img
| `Install
| `Jpeg
| `Js
| `Json
| `Lib
| `Md
| `Ml
| `Ml_dep
| `Ml_pp
| `Mli
| `Mli_dep
| `Mli_pp
| `Native
| `O
| `Opt
| `Png
| `Sh
| `So
| `Tar
| `Tbz
| `Xml
| `Zip ]
val ext_to_string : Assemblage.Path.ext -> string
val ext_of_string : string -> Assemblage.Path.ext
val pp_ext : Format.formatter -> Assemblage.Path.ext -> unit
val ext : Assemblage.Path.t -> Assemblage.Path.ext option
val get_ext : Assemblage.Path.t -> Assemblage.Path.ext
val add_ext :
Assemblage.Path.t -> Assemblage.Path.ext -> Assemblage.Path.t
val rem_ext : Assemblage.Path.t -> Assemblage.Path.t
val change_ext :
Assemblage.Path.t -> Assemblage.Path.ext -> Assemblage.Path.t
val ( + ) :
Assemblage.Path.t -> Assemblage.Path.ext -> Assemblage.Path.t
val has_ext : Assemblage.Path.ext -> Assemblage.Path.t -> bool
val ext_matches : Assemblage.Path.ext list -> Assemblage.Path.t -> bool
module Rel :
sig
type path = Assemblage.Path.t
type t = Assemblage.Path.rel
val empty : Assemblage.Path.rel
val dash : Assemblage.Path.rel
val add : Assemblage.Path.rel -> string -> Assemblage.Path.rel
val concat :
Assemblage.Path.rel -> Assemblage.Path.rel -> Assemblage.Path.rel
val file : Assemblage.Path.filename -> Assemblage.Path.rel
val base : string -> Assemblage.Path.rel
val ( / ) : Assemblage.Path.rel -> string -> Assemblage.Path.rel
val ( // ) :
Assemblage.Path.rel -> Assemblage.Path.rel -> Assemblage.Path.rel
val basename : Assemblage.Path.rel -> string
val dirname : Assemblage.Path.rel -> Assemblage.Path.rel
val rem_prefix :
Assemblage.Path.rel ->
Assemblage.Path.rel -> Assemblage.Path.rel option
val find_prefix :
Assemblage.Path.rel -> Assemblage.Path.rel -> Assemblage.Path.rel
val is_empty : Assemblage.Path.rel -> bool
val is_dash : Assemblage.Path.rel -> bool
val is_prefix : Assemblage.Path.rel -> Assemblage.Path.rel -> bool
val equal : Assemblage.Path.rel -> Assemblage.Path.rel -> bool
val compare : Assemblage.Path.rel -> Assemblage.Path.rel -> int
val to_segs : Assemblage.Path.rel -> string list
val of_segs : string list -> Assemblage.Path.rel
val to_string : Assemblage.Path.rel -> string
val quote : Assemblage.Path.rel -> string
val pp : Format.formatter -> Assemblage.Path.rel -> unit
val ext : Assemblage.Path.rel -> Assemblage.Path.ext option
val get_ext : Assemblage.Path.rel -> Assemblage.Path.ext
val add_ext :
Assemblage.Path.rel -> Assemblage.Path.ext -> Assemblage.Path.rel
val rem_ext : Assemblage.Path.rel -> Assemblage.Path.rel
val change_ext :
Assemblage.Path.rel -> Assemblage.Path.ext -> Assemblage.Path.rel
val ( + ) :
Assemblage.Path.rel -> Assemblage.Path.ext -> Assemblage.Path.rel
val has_ext : Assemblage.Path.ext -> Assemblage.Path.rel -> bool
val ext_matches :
Assemblage.Path.ext list -> Assemblage.Path.rel -> bool
module Set :
sig
type elt = rel
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> Assemblage.Path.Rel.t
end
module Map :
sig
type key = rel
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val dom : 'a Assemblage.Path.Rel.t -> Assemblage.Path.Rel.Set.t
end
end
module Abs :
sig
type path = Assemblage.Path.t
type t = Assemblage.Path.abs
val root : Assemblage.Path.abs
val add : Assemblage.Path.abs -> string -> Assemblage.Path.abs
val concat :
Assemblage.Path.abs -> Assemblage.Path.rel -> Assemblage.Path.abs
val ( / ) : Assemblage.Path.abs -> string -> Assemblage.Path.abs
val ( // ) :
Assemblage.Path.abs -> Assemblage.Path.rel -> Assemblage.Path.abs
val basename : Assemblage.Path.abs -> string
val dirname : Assemblage.Path.abs -> Assemblage.Path.abs
val rem_prefix :
Assemblage.Path.abs ->
Assemblage.Path.abs -> Assemblage.Path.rel option
val find_prefix :
Assemblage.Path.abs -> Assemblage.Path.abs -> Assemblage.Path.abs
val is_root : Assemblage.Path.abs -> bool
val is_prefix : Assemblage.Path.abs -> Assemblage.Path.abs -> bool
val equal : Assemblage.Path.abs -> Assemblage.Path.abs -> bool
val compare : Assemblage.Path.abs -> Assemblage.Path.abs -> int
val to_segs : Assemblage.Path.abs -> string list
val of_segs : string list -> Assemblage.Path.abs
val to_string : Assemblage.Path.abs -> string
val quote : Assemblage.Path.abs -> string
val pp : Format.formatter -> Assemblage.Path.abs -> unit
val ext : Assemblage.Path.abs -> Assemblage.Path.ext option
val get_ext : Assemblage.Path.abs -> Assemblage.Path.ext
val add_ext :
Assemblage.Path.abs -> Assemblage.Path.ext -> Assemblage.Path.abs
val rem_ext : Assemblage.Path.abs -> Assemblage.Path.abs
val change_ext :
Assemblage.Path.abs -> Assemblage.Path.ext -> Assemblage.Path.abs
val ( + ) :
Assemblage.Path.abs -> Assemblage.Path.ext -> Assemblage.Path.abs
val has_ext : Assemblage.Path.ext -> Assemblage.Path.abs -> bool
val ext_matches :
Assemblage.Path.ext list -> Assemblage.Path.abs -> bool
module Set :
sig
type elt = abs
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> Assemblage.Path.Abs.t
end
module Map :
sig
type key = abs
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val dom : 'a Assemblage.Path.Abs.t -> Assemblage.Path.Abs.Set.t
end
end
module Set :
sig
type elt = t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> Assemblage.Path.t
end
module Map :
sig
type key = t
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val dom : 'a Assemblage.Path.t -> Assemblage.Path.Set.t
end
end
module Log :
sig
type level = Show | Error | Warning | Info | Debug
val msg :
?header:string ->
Assemblage.Log.level ->
('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a
val kmsg :
?header:string ->
(unit -> 'a) ->
Assemblage.Log.level ->
('b, Format.formatter, unit, 'a) Pervasives.format4 -> 'b
val show :
?header:string ->
('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a
val err :
?header:string ->
('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a
val warn :
?header:string ->
('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a
val info :
?header:string ->
('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a
val debug :
?header:string ->
('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a
end
module Cmd :
sig
type 'a result = [ `Error of string | `Ok of 'a ]
val ret : 'a -> 'a Assemblage.Cmd.result
val error : string -> 'a Assemblage.Cmd.result
val bind :
'a Assemblage.Cmd.result ->
('a -> 'b Assemblage.Cmd.result) -> 'b Assemblage.Cmd.result
val map :
'a Assemblage.Cmd.result -> ('a -> 'b) -> 'b Assemblage.Cmd.result
val get : 'a Assemblage.Cmd.result -> 'a
val on_error :
?level:Assemblage.Log.level ->
use:'a -> 'a Assemblage.Cmd.result -> 'a
val ignore_error : use:'a -> 'a Assemblage.Cmd.result -> 'a
val reword_error :
?replace:bool ->
string -> 'a Assemblage.Cmd.result -> 'a Assemblage.Cmd.result
val exn_error :
?msg:(Printexc.raw_backtrace -> exn -> 'a -> string) ->
('a -> 'b) -> 'a -> 'b Assemblage.Cmd.result
val ( >>= ) :
'a Assemblage.Cmd.result ->
('a -> 'b Assemblage.Cmd.result) -> 'b Assemblage.Cmd.result
val ( >>| ) :
'a Assemblage.Cmd.result -> ('a -> 'b) -> 'b Assemblage.Cmd.result
module Infix :
sig
val ( >>= ) :
'a Assemblage.Cmd.result ->
('a -> 'b Assemblage.Cmd.result) -> 'b Assemblage.Cmd.result
val ( >>| ) :
'a Assemblage.Cmd.result ->
('a -> 'b) -> 'b Assemblage.Cmd.result
end
type path = Assemblage.Path.t
module Path :
sig
val exists : Assemblage.Cmd.path -> bool Assemblage.Cmd.result
val move :
?force:bool ->
Assemblage.Cmd.path ->
Assemblage.Cmd.path -> unit Assemblage.Cmd.result
end
module File :
sig
val exists : Assemblage.Cmd.path -> bool Assemblage.Cmd.result
val dev_null : Assemblage.Cmd.path
val delete :
?maybe:bool -> Assemblage.Cmd.path -> unit Assemblage.Cmd.result
val temp : string -> Assemblage.Cmd.path Assemblage.Cmd.result
val with_inf :
(Pervasives.in_channel -> 'a -> 'b Assemblage.Cmd.result) ->
Assemblage.Cmd.path -> 'a -> 'b Assemblage.Cmd.result
val read : Assemblage.Cmd.path -> string Assemblage.Cmd.result
val read_lines :
Assemblage.Cmd.path -> string list Assemblage.Cmd.result
val with_outf :
(Pervasives.out_channel -> 'a -> 'b Assemblage.Cmd.result) ->
Assemblage.Cmd.path -> 'a -> 'b Assemblage.Cmd.result
val write :
Assemblage.Cmd.path -> string -> unit Assemblage.Cmd.result
val write_lines :
Assemblage.Cmd.path -> string list -> unit Assemblage.Cmd.result
val write_subst :
(string * string) list ->
Assemblage.Cmd.path -> string -> unit Assemblage.Cmd.result
end
module Dir :
sig
val exists : Assemblage.Cmd.path -> bool Assemblage.Cmd.result
val getcwd : unit -> Assemblage.Cmd.path Assemblage.Cmd.result
val chdir : Assemblage.Cmd.path -> unit Assemblage.Cmd.result
val fold_files_rec :
?skip:string list ->
(string -> 'a -> 'a Assemblage.Cmd.result) ->
'a -> string list -> 'a Assemblage.Cmd.result
end
module Vcs :
sig
type t = [ `Git | `Hg ]
val exists :
Assemblage.Cmd.path ->
Assemblage.Cmd.Vcs.t -> bool Assemblage.Cmd.result
val find :
Assemblage.Cmd.path ->
Assemblage.Cmd.Vcs.t option Assemblage.Cmd.result
val get :
Assemblage.Cmd.path -> Assemblage.Cmd.Vcs.t Assemblage.Cmd.result
val head :
?dirty:bool ->
Assemblage.Cmd.path ->
Assemblage.Cmd.Vcs.t -> string Assemblage.Cmd.result
val describe :
?dirty:bool ->
Assemblage.Cmd.path ->
Assemblage.Cmd.Vcs.t -> string Assemblage.Cmd.result
end
val env : string -> string option
val get_env : string -> string Assemblage.Cmd.result
val exists : string -> bool Assemblage.Cmd.result
val exec_ret : string -> string list -> int
val exec : string -> string list -> unit Assemblage.Cmd.result
val read :
?trim:bool -> string -> string list -> string Assemblage.Cmd.result
val read_lines :
string -> string list -> string list Assemblage.Cmd.result
val write :
string ->
string list -> Assemblage.Cmd.path -> unit Assemblage.Cmd.result
end
module Conf :
sig
type 'a value
val const : 'a -> 'a Assemblage.Conf.value
val app :
('a -> 'b) Assemblage.Conf.value ->
'a Assemblage.Conf.value -> 'b Assemblage.Conf.value
val ( $ ) :
('a -> 'b) Assemblage.Conf.value ->
'a Assemblage.Conf.value -> 'b Assemblage.Conf.value
val true_ : bool Assemblage.Conf.value
val false_ : bool Assemblage.Conf.value
val neg : bool Assemblage.Conf.value -> bool Assemblage.Conf.value
val ( &&& ) :
bool Assemblage.Conf.value ->
bool Assemblage.Conf.value -> bool Assemblage.Conf.value
val ( ||| ) :
bool Assemblage.Conf.value ->
bool Assemblage.Conf.value -> bool Assemblage.Conf.value
val pick_if :
bool Assemblage.Conf.value ->
'a Assemblage.Conf.value ->
'a Assemblage.Conf.value -> 'a Assemblage.Conf.value
module Option :
sig
val wrap :
'a Assemblage.Conf.value option ->
'a option Assemblage.Conf.value
val some :
'a Assemblage.Conf.value -> 'a option Assemblage.Conf.value
val get :
?none:'a Assemblage.Conf.value ->
'a option Assemblage.Conf.value -> 'a Assemblage.Conf.value
end
type 'a parser = string -> [ `Error of string | `Ok of 'a ]
type 'a printer = Format.formatter -> 'a -> unit
type 'a converter =
'a Assemblage.Conf.parser * 'a Assemblage.Conf.printer
val parser : 'a Assemblage.Conf.converter -> 'a Assemblage.Conf.parser
val printer :
'a Assemblage.Conf.converter -> 'a Assemblage.Conf.printer
type 'a key
val key :
?public:bool ->
?docs:string ->
?docv:string ->
?doc:string ->
string ->
'a Assemblage.Conf.converter ->
'a Assemblage.Conf.value -> 'a Assemblage.Conf.key
val value : 'a Assemblage.Conf.key -> 'a Assemblage.Conf.value
type scheme
type def
val def : 'a Assemblage.Conf.key -> 'a -> Assemblage.Conf.def
val defv :
'a Assemblage.Conf.key ->
'a Assemblage.Conf.value -> Assemblage.Conf.def
val scheme :
?doc:string ->
?base:Assemblage.Conf.scheme ->
string -> Assemblage.Conf.def list -> Assemblage.Conf.scheme
val project_version : string Assemblage.Conf.key
val docs_project : string
val debug : bool Assemblage.Conf.key
val profile : bool Assemblage.Conf.key
val warn_error : bool Assemblage.Conf.key
val test : bool Assemblage.Conf.key
val doc : bool Assemblage.Conf.key
val jobs : int Assemblage.Conf.key
val docs_build_properties : string
val root_dir : Assemblage.Path.t Assemblage.Conf.key
val build_dir : Assemblage.Path.rel Assemblage.Conf.key
val docs_build_directories : string
val ocaml_native_tools : bool Assemblage.Conf.key
val ocaml_version :
(int * int * int * string option) Assemblage.Conf.key
val ocaml_byte : bool Assemblage.Conf.key
val ocaml_native : bool Assemblage.Conf.key
val ocaml_native_dynlink : bool Assemblage.Conf.key
val ocaml_js : bool Assemblage.Conf.key
val ocaml_annot : bool Assemblage.Conf.key
val ocaml_build_ast : bool Assemblage.Conf.key
val ocaml_dumpast : string Assemblage.Conf.key
val ocamlc : string Assemblage.Conf.key
val ocamlopt : string Assemblage.Conf.key
val js_of_ocaml : string Assemblage.Conf.key
val ocamlmklib : string Assemblage.Conf.key
val ocamldep : string Assemblage.Conf.key
val ocamllex : string Assemblage.Conf.key
val ocamlyacc : string Assemblage.Conf.key
val ocaml : string Assemblage.Conf.key
val ocamlrun : string Assemblage.Conf.key
val ocamldebug : string Assemblage.Conf.key
val ocamlprof : string Assemblage.Conf.key
val ocamlfind : string Assemblage.Conf.key
val opam : string Assemblage.Conf.key
val opam_installer : string Assemblage.Conf.key
val opam_admin : string Assemblage.Conf.key
val docs_ocaml_system : string
val c_dynlink : bool Assemblage.Conf.key
val c_js : bool Assemblage.Conf.key
val cc : string Assemblage.Conf.key
val pkg_config : string Assemblage.Conf.key
val docs_c_system : string
val uname : string Assemblage.Conf.key
val host_os : string Assemblage.Conf.key
val host_arch : string Assemblage.Conf.key
val host_word_size : int Assemblage.Conf.key
val target_os : string Assemblage.Conf.key
val target_arch : string Assemblage.Conf.key
val target_word_size : int Assemblage.Conf.key
val docs_machine_information : string
val echo : string Assemblage.Conf.key
val cd : string Assemblage.Conf.key
val ln : string Assemblage.Conf.key
val cp : string Assemblage.Conf.key
val mv : string Assemblage.Conf.key
val rm : string Assemblage.Conf.key
val rmdir : string Assemblage.Conf.key
val mkdir : string Assemblage.Conf.key
val cat : string Assemblage.Conf.key
val make : string Assemblage.Conf.key
val docs_system_utilities : string
val bool : bool Assemblage.Conf.converter
val int : int Assemblage.Conf.converter
val string : string Assemblage.Conf.converter
val path : Assemblage.Path.t Assemblage.Conf.converter
val abs_path : Assemblage.Path.abs Assemblage.Conf.converter
val rel_path : Assemblage.Path.rel Assemblage.Conf.converter
val enum : (string * 'a) list -> 'a Assemblage.Conf.converter
val version :
(int * int * int * string option) Assemblage.Conf.converter
end
module Ctx :
sig
type tag = [ `Tag of string ]
type language = [ `C | `Js | `Lang of string | `OCaml ]
type build_phase =
[ `Archive of [ `Shared | `Static ]
| `Compile
| `Dep
| `Doc
| `Gen
| `Link
| `Pp ]
type source = [ `Src of Assemblage.Path.ext ]
type target =
[ `Target of [ `Byte | `Js | `Native | `Other of string | `Src ] ]
type cmd =
[ `Cmd of string Assemblage.Conf.key | `Cmd_static of string ]
type part_usage =
[ `Build | `Dev | `Doc | `Other of string | `Outcome | `Test ]
type part_kind =
[ `Base | `Bin | `Dir | `Doc | `Lib | `Pkg | `Run | `Unit ]
type part =
[ `Part of
[ `Base
| `Bin
| `Build
| `Dev
| `Dir
| `Doc
| `Lib
| `Name of string
| `Other of string
| `Outcome
| `Pkg
| `Run
| `Test
| `Unit ] ]
type elt =
[ `Archive of [ `Shared | `Static ]
| `C
| `Cmd of string Assemblage.Conf.key
| `Cmd_static of string
| `Compile
| `Dep
| `Doc
| `Gen
| `Js
| `Lang of string
| `Link
| `OCaml
| `Part of
[ `Base
| `Bin
| `Build
| `Dev
| `Dir
| `Doc
| `Lib
| `Name of string
| `Other of string
| `Outcome
| `Pkg
| `Run
| `Test
| `Unit ]
| `Pp
| `Src of Assemblage.Path.ext
| `Tag of string
| `Target of [ `Byte | `Js | `Native | `Other of string | `Src ] ]
val pp_elt : Format.formatter -> Assemblage.Ctx.elt -> unit
type t
val v : Assemblage.Ctx.elt list -> Assemblage.Ctx.t
val matches : Assemblage.Ctx.t -> Assemblage.Ctx.t -> bool
val pp : Format.formatter -> Assemblage.Ctx.t -> unit
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
end
module Args :
sig
type t
val v :
?exists:bool Assemblage.Conf.value ->
Assemblage.Ctx.t ->
string list Assemblage.Conf.value -> Assemblage.Args.t
val vc :
?exists:bool Assemblage.Conf.value ->
Assemblage.Ctx.t -> string list -> Assemblage.Args.t
val empty : Assemblage.Args.t
val is_empty : Assemblage.Args.t -> bool
val append :
Assemblage.Args.t -> Assemblage.Args.t -> Assemblage.Args.t
val ( @@@ ) :
Assemblage.Args.t -> Assemblage.Args.t -> Assemblage.Args.t
val concat : Assemblage.Args.t list -> Assemblage.Args.t
val linkall : Assemblage.Args.t
val thread : Assemblage.Args.t
val vmthread : Assemblage.Args.t
val cclib : string list -> Assemblage.Args.t
val ccopt : string list -> Assemblage.Args.t
val stub : string -> Assemblage.Args.t
end
module Acmd :
sig
type cmd
val cmd :
string Assemblage.Conf.key ->
Assemblage.Acmd.cmd Assemblage.Conf.value
val static : string -> Assemblage.Acmd.cmd
type t
val v :
?stdin:Assemblage.Path.t ->
?stdout:Assemblage.Path.t ->
?stderr:Assemblage.Path.t ->
Assemblage.Acmd.cmd -> string list -> Assemblage.Acmd.t
module Args :
sig
val add : 'a -> 'a list -> 'a list
val adds : 'a list -> 'a list -> 'a list
val add_if : bool -> 'a -> 'a list -> 'a list
val adds_if : bool -> 'a list -> 'a list -> 'a list
val fadd_if : bool -> ('b -> 'a) -> 'b -> 'a list -> 'a list
val fadds_if : bool -> ('b -> 'a list) -> 'b -> 'a list -> 'a list
val path_arg :
?opt:string -> Assemblage.Path.t -> string list -> string list
val path_args :
?opt:string ->
Assemblage.Path.t list -> string list -> string list
val path :
Assemblage.Path.t -> ext:Assemblage.Path.ext -> Assemblage.Path.t
end
val dev_null : Assemblage.Path.t Assemblage.Conf.value
val cd : (Assemblage.Path.t -> Assemblage.Acmd.t) Assemblage.Conf.value
val ln :
(Assemblage.Path.t -> Assemblage.Path.t -> Assemblage.Acmd.t)
Assemblage.Conf.value
val ln_rel :
(Assemblage.Path.t -> Assemblage.Path.t -> Assemblage.Acmd.t)
Assemblage.Conf.value
val cp :
(Assemblage.Path.t -> Assemblage.Path.t -> Assemblage.Acmd.t)
Assemblage.Conf.value
val mv :
(Assemblage.Path.t -> Assemblage.Path.t -> Assemblage.Acmd.t)
Assemblage.Conf.value
val rm_files :
(?f:bool -> Assemblage.Path.t list -> Assemblage.Acmd.t)
Assemblage.Conf.value
val rm_dirs :
(?f:bool -> ?r:bool -> Assemblage.Path.t list -> Assemblage.Acmd.t)
Assemblage.Conf.value
val mkdir :
(Assemblage.Path.t -> Assemblage.Acmd.t) Assemblage.Conf.value
val stamp :
(Assemblage.Path.t -> string -> Assemblage.Acmd.t)
Assemblage.Conf.value
end
module Action :
sig
type t
val v :
?log:string ->
?ctx:Assemblage.Ctx.t ->
?inputs:Assemblage.Path.t list ->
?outputs:Assemblage.Path.t list ->
Assemblage.Acmd.t list -> Assemblage.Action.t
val ctx : Assemblage.Action.t -> Assemblage.Ctx.t
val inputs : Assemblage.Action.t -> Assemblage.Path.t list
val outputs : Assemblage.Action.t -> Assemblage.Path.t list
val cmds : Assemblage.Action.t -> Assemblage.Acmd.t list
val log : Assemblage.Action.t -> string option
val products : Assemblage.Action.t -> Assemblage.Path.t list
val symlink :
(Assemblage.Path.t -> Assemblage.Path.t -> Assemblage.Action.t)
Assemblage.Conf.value
val list_inputs : Assemblage.Action.t list -> Assemblage.Path.t list
val list_outputs : Assemblage.Action.t list -> Assemblage.Path.t list
val list_products : Assemblage.Action.t list -> Assemblage.Path.t list
end
type part_kind =
[ `Base | `Bin | `Dir | `Doc | `Lib | `Pkg | `Run | `Unit ]
type +'a part constraint 'a = [< Assemblage.part_kind ]
module Part :
sig
type kind = [ `Base | `Bin | `Dir | `Doc | `Lib | `Pkg | `Run | `Unit ]
val pp_kind : Format.formatter -> Assemblage.Part.kind -> unit
type usage =
[ `Build | `Dev | `Doc | `Other of string | `Outcome | `Test ]
val pp_usage : Format.formatter -> Assemblage.Part.usage -> unit
type meta
val meta_key :
unit ->
('a -> Assemblage.Part.meta) * (Assemblage.Part.meta -> 'a option)
val meta_nil : Assemblage.Part.meta
type +'a t = 'a Assemblage.part
constraint 'a = [< Assemblage.part_kind ]
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?meta:Assemblage.Part.meta ->
?needs:[< Assemblage.part_kind ] Assemblage.part list ->
?root:Assemblage.Path.rel Assemblage.Conf.value ->
?actions:(Assemblage.Part.kind Assemblage.part ->
Assemblage.Action.t list Assemblage.Conf.value) ->
?check:(Assemblage.Part.kind Assemblage.part ->
bool Assemblage.Conf.value) ->
string -> [< Assemblage.part_kind > `Base ] Assemblage.part
val kind :
[< Assemblage.part_kind ] Assemblage.part -> Assemblage.Part.kind
val name : [< Assemblage.part_kind ] Assemblage.part -> string
val usage :
[< Assemblage.part_kind ] Assemblage.part -> Assemblage.Part.usage
val exists :
[< Assemblage.part_kind ] Assemblage.part ->
bool Assemblage.Conf.value
val meta :
[< Assemblage.part_kind ] Assemblage.part -> Assemblage.Part.meta
val get_meta :
(Assemblage.Part.meta -> 'a option) ->
[< Assemblage.part_kind ] Assemblage.Part.t -> 'a
val root :
[< Assemblage.part_kind ] Assemblage.part ->
Assemblage.Path.rel Assemblage.Conf.value
val root_path :
[< Assemblage.part_kind ] Assemblage.part ->
Assemblage.Path.t Assemblage.Conf.value
val needs :
[< Assemblage.part_kind ] Assemblage.part ->
Assemblage.Part.kind Assemblage.Part.t list
val actions :
[< Assemblage.part_kind ] Assemblage.part ->
Assemblage.Action.t list Assemblage.Conf.value
val check :
[< Assemblage.part_kind ] Assemblage.part ->
bool Assemblage.Conf.value
val id : [< Assemblage.part_kind ] Assemblage.part -> int
val equal :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind ] Assemblage.part -> bool
val compare :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind ] Assemblage.part -> int
val redefine :
?check:(Assemblage.Part.kind Assemblage.part ->
bool Assemblage.Conf.value) ->
?actions:(Assemblage.Part.kind Assemblage.part ->
Assemblage.Action.t list Assemblage.Conf.value) ->
([< Assemblage.part_kind ] as 'a) Assemblage.part ->
'a Assemblage.part
val file :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
Assemblage.Path.t ->
[< Assemblage.part_kind > `Base ] Assemblage.part
val integrate :
?add_need:(Assemblage.Part.kind Assemblage.part -> bool) ->
([< Assemblage.part_kind ] as 'a) Assemblage.part ->
[< Assemblage.part_kind ] Assemblage.part -> 'a Assemblage.part
val coerce :
([< Assemblage.part_kind ] as 'a) ->
[< Assemblage.part_kind ] Assemblage.part -> 'a Assemblage.part
val coerce_if :
([< Assemblage.part_kind ] as 'a) ->
[< Assemblage.part_kind ] Assemblage.part ->
'a Assemblage.part option
val list_actions :
Assemblage.Part.kind Assemblage.part list ->
Assemblage.Action.t list Assemblage.Conf.value
val list_uniquify :
Assemblage.Part.kind Assemblage.part list ->
Assemblage.Part.kind Assemblage.part list
val list_keep :
(([< Assemblage.part_kind ] as 'a) Assemblage.part -> bool) ->
'a Assemblage.part list -> 'a Assemblage.part list
val list_keep_map :
(([< Assemblage.part_kind ] as 'a) Assemblage.part -> 'b option) ->
'a Assemblage.part list -> 'b list
val list_keep_kind :
([< Assemblage.part_kind ] as 'a) ->
[< Assemblage.part_kind ] Assemblage.part list ->
'a Assemblage.part list
val list_keep_kinds :
Assemblage.Part.kind list ->
([< Assemblage.part_kind ] as 'a) Assemblage.part list ->
'a Assemblage.part list
val list_fold :
('a -> ([< Assemblage.part_kind ] as 'b) Assemblage.part -> 'a) ->
'a -> 'b Assemblage.part list -> 'a
val list_fold_kind :
([< Assemblage.part_kind ] as 'b) ->
('a -> 'b Assemblage.part -> 'a) ->
'a -> [< Assemblage.part_kind ] Assemblage.part list -> 'a
val list_fold_rec :
('a -> Assemblage.Part.kind Assemblage.part -> 'a) ->
'a -> Assemblage.Part.kind Assemblage.part list -> 'a
val list_fold_kind_rec :
([< Assemblage.part_kind ] as 'b) ->
('a -> 'b Assemblage.Part.t -> 'a) ->
'a -> Assemblage.Part.kind Assemblage.Part.t list -> 'a
module Set :
sig
type elt = kind part
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list :
Assemblage.Part.kind Assemblage.part list -> Assemblage.Part.t
end
module Map :
sig
type key = kind part
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val dom : 'a Assemblage.Part.t -> Assemblage.Part.Set.t
end
end
module Unit :
sig
type ocaml_interface = [ `Hidden | `Normal | `Opaque ]
type ocaml_unit = [ `Both | `Ml | `Mli ]
type c_unit = [ `Both | `C | `H ]
type kind =
[ `C of Assemblage.Unit.c_unit
| `Js
| `OCaml of
Assemblage.Unit.ocaml_unit * Assemblage.Unit.ocaml_interface ]
val pp_kind : Format.formatter -> Assemblage.Unit.kind -> unit
val kind : [< `Unit ] Assemblage.part -> Assemblage.Unit.kind
val dir :
[< `Unit ] Assemblage.part -> Assemblage.Path.t Assemblage.Conf.value
val ocaml :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Unit ] Assemblage.part option
val c :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Unit ] Assemblage.part option
val js :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Unit ] Assemblage.part option
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?needs:[< `Lib | `Pkg ] Assemblage.part list ->
?dir:Assemblage.Path.t Assemblage.Conf.value ->
string ->
Assemblage.Unit.kind ->
[< Assemblage.part_kind > `Unit ] Assemblage.part
end
module Lib :
sig
type kind = [ `C | `OCaml | `OCaml_pp ]
val pp_kind : Format.formatter -> Assemblage.Lib.kind -> unit
val kind : [< `Lib ] Assemblage.part -> Assemblage.Lib.kind
val byte : [< `Lib ] Assemblage.part -> bool
val native : [< `Lib ] Assemblage.part -> bool
val native_dynlink : [< `Lib ] Assemblage.part -> bool
val ocaml :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Lib ] Assemblage.part option
val ocaml_pp :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Lib ] Assemblage.part option
val c :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Lib ] Assemblage.part option
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?byte:bool ->
?native:bool ->
?native_dynlink:bool ->
string ->
Assemblage.Lib.kind ->
[< `Lib | `Pkg | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Lib ] Assemblage.part
end
module Bin :
sig
type kind = [ `C | `OCaml | `OCaml_toplevel ]
val pp_kind : Format.formatter -> Assemblage.Bin.kind -> unit
val kind : [< `Bin ] Assemblage.part -> Assemblage.Bin.kind
val byte : [< `Bin ] Assemblage.part -> bool
val native : [< `Bin ] Assemblage.part -> bool
val js : [< `Bin ] Assemblage.part -> bool
val ocaml :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Bin ] Assemblage.part option
val ocaml_toplevel :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Bin ] Assemblage.part option
val c :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Bin ] Assemblage.part option
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?byte:bool ->
?native:bool ->
?js:bool ->
string ->
Assemblage.Bin.kind ->
[< `Lib | `Pkg | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Bin ] Assemblage.part
val to_cmd :
?ext:Assemblage.Path.ext ->
[< `Bin ] Assemblage.part ->
Assemblage.Acmd.cmd Assemblage.Conf.value
val to_cmd_path :
?abs:bool ->
?ext:Assemblage.Path.ext ->
[< `Bin ] Assemblage.part -> Assemblage.Path.t Assemblage.Conf.value
val exists :
?ext:Assemblage.Path.ext ->
[< `Bin ] Assemblage.part -> bool Assemblage.Conf.value
val gen :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?dir:Assemblage.Path.t Assemblage.Conf.value ->
?name:string ->
?ext:Assemblage.Path.ext ->
?stdin:Assemblage.Path.t Assemblage.Conf.value ->
?stdout:Assemblage.Path.t Assemblage.Conf.value ->
?stderr:Assemblage.Path.t Assemblage.Conf.value ->
[< `Bin ] Assemblage.Part.t ->
string list Assemblage.Conf.value ->
[< Assemblage.part_kind > `Base ] Assemblage.Part.t
end
module Pkg :
sig
type lookup = Assemblage.Ctx.t -> string list
type kind =
[ `OCamlfind
| `Other of string * Assemblage.Pkg.lookup Assemblage.Conf.value
| `Pkg_config ]
val pp_kind : Format.formatter -> Assemblage.Pkg.kind -> unit
val kind : [< `Pkg ] Assemblage.part -> Assemblage.Pkg.kind
val lookup :
[< `Pkg ] Assemblage.part ->
Assemblage.Pkg.lookup Assemblage.Conf.value
val opt : [< `Pkg ] Assemblage.part -> bool
val ocamlfind :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Pkg ] Assemblage.part option
val pkg_config :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Pkg ] Assemblage.part option
val other :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Pkg ] Assemblage.part option
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?opt:bool ->
string ->
Assemblage.Pkg.kind ->
[< Assemblage.part_kind > `Pkg ] Assemblage.part
val list_lookup :
[< Assemblage.part_kind ] Assemblage.part list ->
Assemblage.Pkg.lookup Assemblage.Conf.value
end
module Doc :
sig
type kind = [ `OCamldoc ]
val pp_kind : Format.formatter -> Assemblage.Doc.kind -> unit
val kind : [< `Doc ] Assemblage.part -> Assemblage.Doc.kind
val ocamldoc :
[< Assemblage.part_kind ] Assemblage.part ->
[< Assemblage.part_kind > `Doc ] Assemblage.part option
val default : [< `Unit ] Assemblage.part -> bool
val dev : [< `Unit ] Assemblage.part -> bool
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?keep:([< `Unit ] Assemblage.part -> bool) ->
string ->
Assemblage.Doc.kind ->
[< `Bin | `Lib | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Doc ] Assemblage.part
end
module Dir :
sig
type kind =
[ `Bin
| `Doc
| `Etc
| `Lib
| `Man
| `Other of Assemblage.Path.t
| `Sbin
| `Share
| `Share_root
| `Stublibs
| `Toplevel ]
val pp_kind : Format.formatter -> Assemblage.Dir.kind -> unit
val kind : [< `Dir ] Assemblage.part -> Assemblage.Dir.kind
val install : [< `Dir ] Assemblage.part -> bool
type spec =
Assemblage.Part.kind Assemblage.Part.t ->
(Assemblage.Path.t * Assemblage.Path.rel option) list
Assemblage.Conf.value
val all : Assemblage.Dir.spec
val all_output : Assemblage.Dir.spec
val all_input : Assemblage.Dir.spec
val file_exts : Assemblage.Path.ext list -> Assemblage.Dir.spec
val bin : Assemblage.Dir.spec
val lib : Assemblage.Dir.spec
val doc : Assemblage.Dir.spec
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?spec:Assemblage.Dir.spec ->
?install:bool ->
Assemblage.Dir.kind ->
[< `Base | `Bin | `Dir | `Doc | `Lib | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Dir ] Assemblage.part
end
module Run :
sig
val v :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?dir:Assemblage.Path.t Assemblage.Conf.value ->
string ->
Assemblage.Action.t Assemblage.Conf.value ->
[< Assemblage.part_kind > `Run ] Assemblage.part
val with_bin :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?dir:Assemblage.Path.t Assemblage.Conf.value ->
?name:string ->
?ext:Assemblage.Path.ext ->
[< `Bin ] Assemblage.part ->
(Assemblage.Acmd.cmd -> Assemblage.Acmd.t list) Assemblage.Conf.value ->
[< Assemblage.part_kind > `Run ] Assemblage.part
val bin :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?dir:Assemblage.Path.t Assemblage.Conf.value ->
?name:string ->
?ext:Assemblage.Path.ext ->
?stdin:Assemblage.Path.t Assemblage.Conf.value ->
?stdout:Assemblage.Path.t Assemblage.Conf.value ->
?stderr:Assemblage.Path.t Assemblage.Conf.value ->
[< `Bin ] Assemblage.part ->
string list Assemblage.Conf.value ->
[< Assemblage.part_kind > `Run ] Assemblage.part
end
type path = Assemblage.Path.t Assemblage.Conf.value
val root : Assemblage.path
val ( / ) : Assemblage.path -> string -> Assemblage.path
val ( // ) :
Assemblage.path ->
Assemblage.Path.rel Assemblage.Conf.value -> Assemblage.path
val unit :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?needs:[< `Lib | `Pkg ] Assemblage.part list ->
?kind:Assemblage.Unit.kind ->
?dir:Assemblage.path ->
string -> [< Assemblage.part_kind > `Unit ] Assemblage.part
val lib :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?byte:bool ->
?native:bool ->
?native_dynlink:bool ->
?kind:Assemblage.Lib.kind ->
string ->
[< `Lib | `Pkg | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Lib ] Assemblage.part
val bin :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?byte:bool ->
?native:bool ->
?js:bool ->
?kind:Assemblage.Bin.kind ->
string ->
[< `Lib | `Pkg | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Bin ] Assemblage.part
val pkg :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?opt:bool ->
?kind:Assemblage.Pkg.kind ->
string -> [< Assemblage.part_kind > `Pkg ] Assemblage.part
val doc :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?keep:([< `Unit ] Assemblage.part -> bool) ->
?kind:Assemblage.Doc.kind ->
string ->
[< `Bin | `Lib | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Doc ] Assemblage.part
val dir :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?spec:Assemblage.Dir.spec ->
?install:bool ->
Assemblage.Dir.kind ->
[< `Base | `Bin | `Dir | `Doc | `Lib | `Unit ] Assemblage.part list ->
[< Assemblage.part_kind > `Dir ] Assemblage.part
val file :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
Assemblage.Path.t -> [< Assemblage.part_kind > `Base ] Assemblage.part
val run :
?usage:Assemblage.Part.usage ->
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?dir:Assemblage.path ->
string ->
Assemblage.Action.t Assemblage.Conf.value ->
[< Assemblage.part_kind > `Run ] Assemblage.part
type project
module Project :
sig
type t = Assemblage.project
val v :
?exists:bool Assemblage.Conf.value ->
?args:Assemblage.Args.t ->
?schemes:Assemblage.Conf.scheme list ->
string ->
parts:[< Assemblage.part_kind ] Assemblage.part list ->
Assemblage.project
val name : Assemblage.project -> string
end
val assemble : Assemblage.project -> unit
module Private :
sig
module Fmt :
sig
type 'a formatter = Format.formatter -> 'a -> unit
val pp :
Format.formatter -> ('a, Format.formatter, unit) format -> 'a
val rpp :
('a, Format.formatter, unit) format -> Format.formatter -> 'a
val nop : 'a formatter
val pp_cut : unit formatter
val pp_sp : unit formatter
val pp_str : string formatter
val pp_int : int formatter
val pp_bool : bool formatter
val pp_larrow : unit formatter
val pp_rarrow : unit formatter
val pp_opt :
?pp_none:unit formatter -> 'a formatter -> 'a option formatter
val pp_list :
?pp_sep:unit formatter -> 'a formatter -> 'a list formatter
val pp_text : string formatter
val pp_lines : string formatter
val pp_doomed : string formatter
val pp_if_utf8 : 'a formatter -> 'a formatter -> 'a formatter
type style =
[ `Black
| `Blue
| `Bold
| `Cyan
| `Green
| `Magenta
| `None
| `Red
| `Underline
| `White
| `Yellow ]
val pp_styled : style -> 'a formatter -> 'a formatter
val pp_styled_str : style -> string formatter
val utf8_enabled : unit -> bool
val set_utf8_enabled : bool -> unit
type style_tags = [ `Ansi | `None ]
val style_tags : unit -> Assemblage.Private.Fmt.style_tags
val set_style_tags : Assemblage.Private.Fmt.style_tags -> unit
end
module Log :
sig
type level = Log.level = Show | Error | Warning | Info | Debug
val msg :
?header:string ->
level -> ('a, Format.formatter, unit, unit) format4 -> 'a
val kmsg :
?header:string ->
(unit -> 'a) ->
level -> ('b, Format.formatter, unit, 'a) format4 -> 'b
val show :
?header:string ->
('a, Format.formatter, unit, unit) format4 -> 'a
val err :
?header:string ->
('a, Format.formatter, unit, unit) format4 -> 'a
val warn :
?header:string ->
('a, Format.formatter, unit, unit) format4 -> 'a
val info :
?header:string ->
('a, Format.formatter, unit, unit) format4 -> 'a
val debug :
?header:string ->
('a, Format.formatter, unit, unit) format4 -> 'a
val level : unit -> level option
val set_level : level option -> unit
val set_formatter :
[ `All | `Level of level ] -> Format.formatter -> unit
val err_count : unit -> int
val warn_count : unit -> int
end
module Cmd :
sig
module Vcs :
sig
type t = [ `Git | `Hg ]
val exists : Cmd.path -> t -> bool Cmd.result
val find : Cmd.path -> t option Cmd.result
val get : Cmd.path -> t Cmd.result
val head : ?dirty:bool -> Cmd.path -> t -> string Cmd.result
val describe :
?dirty:bool -> Cmd.path -> t -> string Cmd.result
val override_kind : unit -> t option
val set_override_kind : t option -> unit
val override_exec : unit -> string option
val set_override_exec : string option -> unit
end
type 'a result = [ `Error of string | `Ok of 'a ]
val ret : 'a -> 'a result
val error : string -> 'a result
val bind : 'a result -> ('a -> 'b result) -> 'b result
val map : 'a result -> ('a -> 'b) -> 'b result
val get : 'a result -> 'a
val on_error : ?level:Log.level -> use:'a -> 'a result -> 'a
val ignore_error : use:'a -> 'a result -> 'a
val reword_error :
?replace:bool -> string -> 'a result -> 'a result
val exn_error :
?msg:(Printexc.raw_backtrace -> exn -> 'a -> string) ->
('a -> 'b) -> 'a -> 'b result
val ( >>= ) : 'a result -> ('a -> 'b result) -> 'b result
val ( >>| ) : 'a result -> ('a -> 'b) -> 'b result
module Infix :
sig
val ( >>= ) : 'a result -> ('a -> 'b result) -> 'b result
val ( >>| ) : 'a result -> ('a -> 'b) -> 'b result
end
type path = Path.t
module Path :
sig
val exists : path -> bool result
val move : ?force:bool -> path -> path -> unit result
end
module File :
sig
val exists : path -> bool result
val dev_null : path
val delete : ?maybe:bool -> path -> unit result
val temp : string -> path result
val with_inf :
(in_channel -> 'a -> 'b result) -> path -> 'a -> 'b result
val read : path -> string result
val read_lines : path -> string list result
val with_outf :
(out_channel -> 'a -> 'b result) -> path -> 'a -> 'b result
val write : path -> string -> unit result
val write_lines : path -> string list -> unit result
val write_subst :
(string * string) list -> path -> string -> unit result
end
module Dir :
sig
val exists : path -> bool result
val getcwd : unit -> path result
val chdir : path -> unit result
val fold_files_rec :
?skip:string list ->
(string -> 'a -> 'a result) -> 'a -> string list -> 'a result
end
val env : string -> string option
val get_env : string -> string result
val exists : string -> bool result
val exec_ret : string -> string list -> int
val exec : string -> string list -> unit result
val read : ?trim:bool -> string -> string list -> string result
val read_lines : string -> string list -> string list result
val write : string -> string list -> path -> unit result
end
module Conf :
sig
type t
type 'a value = 'a Conf.value
val const : 'a -> 'a value
val app : ('a -> 'b) value -> 'a value -> 'b value
val ( $ ) : ('a -> 'b) value -> 'a value -> 'b value
val true_ : bool value
val false_ : bool value
val neg : bool value -> bool value
val ( &&& ) : bool value -> bool value -> bool value
val ( ||| ) : bool value -> bool value -> bool value
val pick_if : bool value -> 'a value -> 'a value -> 'a value
module Option :
sig
val wrap : 'a value option -> 'a option value
val some : 'a value -> 'a option value
val get : ?none:'a value -> 'a option value -> 'a value
end
type 'a parser = string -> [ `Error of string | `Ok of 'a ]
type 'a printer = Format.formatter -> 'a -> unit
type 'a converter = 'a parser * 'a printer
val parser : 'a converter -> 'a parser
val printer : 'a converter -> 'a printer
type 'a key = 'a Conf.key
val key :
?public:bool ->
?docs:string ->
?docv:string ->
?doc:string -> string -> 'a converter -> 'a value -> 'a key
val value : 'a key -> 'a value
type scheme = string * (string * t)
type def = Conf.def
val def : 'a key -> 'a -> def
val defv : 'a key -> 'a value -> def
val scheme :
?doc:string -> ?base:scheme -> string -> def list -> scheme
val project_version : string key
val docs_project : string
val debug : bool key
val profile : bool key
val warn_error : bool key
val test : bool key
val doc : bool key
val jobs : int key
val docs_build_properties : string
val root_dir : Path.t key
val build_dir : Path.rel key
val docs_build_directories : string
val ocaml_native_tools : bool key
val ocaml_version : (int * int * int * string option) key
val ocaml_byte : bool key
val ocaml_native : bool key
val ocaml_native_dynlink : bool key
val ocaml_js : bool key
val ocaml_annot : bool key
val ocaml_build_ast : bool key
val ocaml_dumpast : string key
val ocamlc : string key
val ocamlopt : string key
val js_of_ocaml : string key
val ocamlmklib : string key
val ocamldep : string key
val ocamllex : string key
val ocamlyacc : string key
val ocaml : string key
val ocamlrun : string key
val ocamldebug : string key
val ocamlprof : string key
val ocamlfind : string key
val opam : string key
val opam_installer : string key
val opam_admin : string key
val docs_ocaml_system : string
val c_dynlink : bool key
val c_js : bool key
val cc : string key
val pkg_config : string key
val docs_c_system : string
val uname : string key
val host_os : string key
val host_arch : string key
val host_word_size : int key
val target_os : string key
val target_arch : string key
val target_word_size : int key
val docs_machine_information : string
val echo : string key
val cd : string key
val ln : string key
val cp : string key
val mv : string key
val rm : string key
val rmdir : string key
val mkdir : string key
val cat : string key
val make : string key
val docs_system_utilities : string
val bool : bool converter
val int : int converter
val string : string converter
val path : Path.t converter
val abs_path : Path.abs converter
val rel_path : Path.rel converter
val enum : (string * 'a) list -> 'a converter
val version : (int * int * int * string option) converter
module Key :
sig
type t = V : 'a key -> Assemblage.Private.Conf.Key.t
val hide_type : 'a key -> Assemblage.Private.Conf.Key.t
val equal :
Assemblage.Private.Conf.Key.t ->
Assemblage.Private.Conf.Key.t -> bool
val compare :
Assemblage.Private.Conf.Key.t ->
Assemblage.Private.Conf.Key.t -> int
val id : 'a key -> int
val name : 'a key -> string
val public : 'a key -> bool
val converter : 'a key -> 'a converter
val default : 'a key -> 'a value
val doc : 'a key -> string option
val docv : 'a key -> string option
val docs : 'a key -> string option
module Set :
sig
type elt = t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> Assemblage.Private.Conf.Key.t
end
module Map :
sig
type key = t
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val dom :
'a Assemblage.Private.Conf.Key.t ->
Assemblage.Private.Conf.Key.Set.t
end
end
val empty : Assemblage.Private.Conf.t
val is_empty : Assemblage.Private.Conf.t -> bool
val mem : Assemblage.Private.Conf.t -> 'a key -> bool
val add :
Assemblage.Private.Conf.t -> 'a key -> Assemblage.Private.Conf.t
val set :
Assemblage.Private.Conf.t ->
'a key -> 'a value -> Assemblage.Private.Conf.t
val rem :
Assemblage.Private.Conf.t -> 'a key -> Assemblage.Private.Conf.t
val merge :
Assemblage.Private.Conf.t ->
Assemblage.Private.Conf.t -> Assemblage.Private.Conf.t
val find : Assemblage.Private.Conf.t -> 'a key -> 'a value option
val get : Assemblage.Private.Conf.t -> 'a key -> 'a value
val pp : Format.formatter -> Assemblage.Private.Conf.t -> unit
val of_keys :
Assemblage.Private.Conf.Key.Set.t -> Assemblage.Private.Conf.t
val domain :
Assemblage.Private.Conf.t -> Assemblage.Private.Conf.Key.Set.t
val pp_key_dup :
Format.formatter -> Assemblage.Private.Conf.Key.t -> unit
val deps : 'a value -> Assemblage.Private.Conf.Key.Set.t
val eval : Assemblage.Private.Conf.t -> 'a value -> 'a
val doc_project : string
val doc_build_properties : string
val doc_build_directories : string
val doc_ocaml_system : string
val doc_c_system : string
val doc_machine_information : string
val doc_system_utilities : string
end
module Args :
sig
type t = Args.t
val v :
?exists:bool Conf.value -> Ctx.t -> string list Conf.value -> t
val vc : ?exists:bool Conf.value -> Ctx.t -> string list -> t
val empty : t
val is_empty : t -> bool
val append : t -> t -> t
val ( @@@ ) : t -> t -> t
val concat : t list -> t
val linkall : t
val thread : t
val vmthread : t
val cclib : string list -> t
val ccopt : string list -> t
val stub : string -> t
val deps : t -> Assemblage.Private.Conf.Key.Set.t
val pp : Assemblage.Private.Conf.t -> Format.formatter -> t -> unit
val for_ctx :
Assemblage.Private.Conf.t -> Assemblage.Ctx.t -> t -> string list
end
module Acmd :
sig
type args = Assemblage.Private.Args.t
type cmd = Acmd.cmd
val cmd : string Conf.key -> cmd Conf.value
val static : string -> cmd
type t = Acmd.t
val v :
?stdin:Path.t ->
?stdout:Path.t -> ?stderr:Path.t -> cmd -> string list -> t
module Args :
sig
val add : 'a -> 'a list -> 'a list
val adds : 'a list -> 'a list -> 'a list
val add_if : bool -> 'a -> 'a list -> 'a list
val adds_if : bool -> 'a list -> 'a list -> 'a list
val fadd_if : bool -> ('b -> 'a) -> 'b -> 'a list -> 'a list
val fadds_if :
bool -> ('b -> 'a list) -> 'b -> 'a list -> 'a list
val path_arg :
?opt:string -> Path.t -> string list -> string list
val path_args :
?opt:string -> Path.t list -> string list -> string list
val path : Path.t -> ext:Path.ext -> Path.t
end
val dev_null : Path.t Conf.value
val cd : (Path.t -> t) Conf.value
val ln : (Path.t -> Path.t -> t) Conf.value
val ln_rel : (Path.t -> Path.t -> t) Conf.value
val cp : (Path.t -> Path.t -> t) Conf.value
val mv : (Path.t -> Path.t -> t) Conf.value
val rm_files : (?f:bool -> Path.t list -> t) Conf.value
val rm_dirs : (?f:bool -> ?r:bool -> Path.t list -> t) Conf.value
val mkdir : (Path.t -> t) Conf.value
val stamp : (Path.t -> string -> t) Conf.value
val cmd_key : t -> string Assemblage.Private.Conf.key option
val cmd_name : t -> string
val args : t -> string list
val stdin : t -> Assemblage.Path.t option
val stdout : t -> Assemblage.Path.t option
val stderr : t -> Assemblage.Path.t option
val pp : Format.formatter -> t -> unit
val ctx : Assemblage.Ctx.t -> t -> Assemblage.Ctx.t
val args_with_ctx :
Assemblage.Private.Conf.t ->
Assemblage.Ctx.t ->
Assemblage.Private.Acmd.args -> t -> string list
end
module Action :
sig
type t = Action.t
val v :
?log:string ->
?ctx:Ctx.t ->
?inputs:Path.t list -> ?outputs:Path.t list -> Acmd.t list -> t
val ctx : t -> Ctx.t
val inputs : t -> Path.t list
val outputs : t -> Path.t list
val cmds : t -> Acmd.t list
val log : t -> string option
val products : t -> Path.t list
val symlink : (Path.t -> Path.t -> t) Conf.value
val list_inputs : t list -> Path.t list
val list_outputs : t list -> Path.t list
val list_products : t list -> Path.t list
val args : t -> Assemblage.Private.Args.t
val pp : Assemblage.Private.Conf.t -> Format.formatter -> t -> unit
end
module Part :
sig
type kind = Part.kind
val pp_kind : Format.formatter -> kind -> unit
type usage =
[ `Build | `Dev | `Doc | `Other of string | `Outcome | `Test ]
val pp_usage : Format.formatter -> usage -> unit
type meta = Part.meta
val meta_key : unit -> ('a -> meta) * (meta -> 'a option)
val meta_nil : meta
type +'a t = 'a Part.t constraint 'a = [< part_kind ]
val v :
?usage:usage ->
?exists:bool Conf.value ->
?args:Args.t ->
?meta:meta ->
?needs:[< part_kind ] part list ->
?root:Path.rel Conf.value ->
?actions:(kind part -> Action.t list Conf.value) ->
?check:(kind part -> bool Conf.value) ->
string -> [< part_kind > `Base ] part
val kind : [< part_kind ] part -> kind
val name : [< part_kind ] part -> string
val usage : [< part_kind ] part -> usage
val exists : [< part_kind ] part -> bool Conf.value
val meta : [< part_kind ] part -> meta
val get_meta : (meta -> 'a option) -> [< part_kind ] t -> 'a
val root : [< part_kind ] part -> Path.rel Conf.value
val root_path : [< part_kind ] part -> Path.t Conf.value
val needs : [< part_kind ] part -> kind t list
val actions : [< part_kind ] part -> Action.t list Conf.value
val check : [< part_kind ] part -> bool Conf.value
val id : [< part_kind ] part -> int
val equal : [< part_kind ] part -> [< part_kind ] part -> bool
val compare : [< part_kind ] part -> [< part_kind ] part -> int
val redefine :
?check:(kind part -> bool Conf.value) ->
?actions:(kind part -> Action.t list Conf.value) ->
([< part_kind ] as 'a) part -> 'a part
val file :
?usage:usage ->
?exists:bool Conf.value -> Path.t -> [< part_kind > `Base ] part
val integrate :
?add_need:(kind part -> bool) ->
([< part_kind ] as 'a) part -> [< part_kind ] part -> 'a part
val coerce :
([< part_kind ] as 'a) -> [< part_kind ] part -> 'a part
val coerce_if :
([< part_kind ] as 'a) -> [< part_kind ] part -> 'a part option
val list_actions : kind part list -> Action.t list Conf.value
val list_uniquify : kind part list -> kind part list
val list_keep :
(([< part_kind ] as 'a) part -> bool) ->
'a part list -> 'a part list
val list_keep_map :
(([< part_kind ] as 'a) part -> 'b option) ->
'a part list -> 'b list
val list_keep_kind :
([< part_kind ] as 'a) ->
[< part_kind ] part list -> 'a part list
val list_keep_kinds :
kind list -> ([< part_kind ] as 'a) part list -> 'a part list
val list_fold :
('a -> ([< part_kind ] as 'b) part -> 'a) ->
'a -> 'b part list -> 'a
val list_fold_kind :
([< part_kind ] as 'b) ->
('a -> 'b part -> 'a) -> 'a -> [< part_kind ] part list -> 'a
val list_fold_rec :
('a -> kind part -> 'a) -> 'a -> kind part list -> 'a
val list_fold_kind_rec :
([< part_kind ] as 'b) ->
('a -> 'b t -> 'a) -> 'a -> kind t list -> 'a
module Set :
sig
type elt = kind part
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : kind part list -> t
end
module Map :
sig
type key = kind part
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val dom : 'a t -> Set.t
end
val args :
[< Assemblage.part_kind ] Assemblage.part ->
Assemblage.Private.Args.t
val ctx :
[< Assemblage.part_kind ] Assemblage.part -> Assemblage.Ctx.t
val deps :
[< Assemblage.part_kind ] Assemblage.part ->
Assemblage.Private.Conf.Key.Set.t
end
module Project :
sig
type t = Project.t
val v :
?exists:bool Conf.value ->
?args:Args.t ->
?schemes:Conf.scheme list ->
string -> parts:[< part_kind ] part list -> project
val name : project -> string
val exists :
Assemblage.project -> bool Assemblage.Private.Conf.value
val args : Assemblage.project -> Assemblage.Private.Args.t
val schemes :
Assemblage.project -> Assemblage.Private.Conf.scheme list
val parts :
Assemblage.project -> Assemblage.part_kind Assemblage.part list
val deps : Assemblage.project -> Assemblage.Private.Conf.Key.Set.t
val conf : Assemblage.project -> Assemblage.Private.Conf.t
val with_conf :
Assemblage.project ->
Assemblage.Private.Conf.t -> Assemblage.project
val eval :
Assemblage.project -> 'a Assemblage.Private.Conf.value -> 'a
val eval_key :
Assemblage.project -> 'a Assemblage.Private.Conf.key -> 'a
val version : Assemblage.project -> string
val products :
?kind:[ `Any | `Input | `Output | `Source ] ->
Assemblage.project -> Assemblage.Path.Set.t
val watermark_string : ?suffix:string -> t -> string
val pp_signature : Format.formatter -> t -> unit
val list : unit -> Assemblage.project list
end
end
end