sig   type t   type id = int   val create :     ?loc:B0.Def.loc ->     ?src_root:B0.Fpath.t ->     ?doc:string ->     ?doc_outcome:string ->     ?only_aim:B0.Env.build_aim ->     ?pkg:B0.Pkg.t ->     ?meta:B0.Meta.Unit.t -> string -> (B0.build -> unit) -> B0.Unit.t   val value_kind : string   val name : t -> string   val loc : t -> Def.loc   val doc : t -> string   val equal : t -> t -> bool   val compare : t -> t -> int   val compare_by_name : t -> t -> int   val find : string -> t option   val get : string -> t   val get_or_suggest : string -> (t, string list) result   val list : unit -> t list   val pp_name_str : string Fmt.t   val pp_name : t Fmt.t   val pp_synopsis : t Fmt.t   val pp_info : t Fmt.t   val pp_info_ext : t Fmt.t -> t Fmt.t   val func : B0.Unit.t -> B0.build -> unit   val src_root : B0.Unit.t -> B0.Fpath.t   val basename : B0.Unit.t -> string   val doc_outcome : B0.Unit.t -> string   val id : B0.Unit.t -> B0.Unit.id   val pkg : B0.Unit.t -> B0.Pkg.t option   val meta : B0.Unit.t -> B0.Meta.Unit.t   val meta_mem : 'B0.Meta.Unit.key -> B0.Unit.t -> bool   val meta_add : 'B0.Meta.Unit.key -> '-> B0.Unit.t -> unit   val meta_find : 'B0.Meta.Unit.key -> B0.Unit.t -> 'a option   val meta_get : 'B0.Meta.Unit.key -> B0.Unit.t -> 'a   val has_tag : bool B0.Meta.Unit.key -> B0.Unit.t -> bool   module Idset :     sig       type t       val empty : t       val is_empty : t -> bool       val mem : id -> t -> bool       val add : id -> t -> t       val singleton : id -> t       val remove : id -> 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 : (id -> unit) -> t -> unit       val fold : (id -> '-> 'a) -> t -> '-> 'a       val for_all : (id -> bool) -> t -> bool       val exists : (id -> bool) -> t -> bool       val filter : (id -> bool) -> t -> t       val partition : (id -> bool) -> t -> t * t       val cardinal : t -> int       val elements : t -> id list       val min_elt : t -> id       val max_elt : t -> id       val choose : t -> id       val split : id -> t -> t * bool * t       val find : id -> t -> id       val of_list : id list -> t       val pp :         ?sep:unit B0.Fmt.t -> B0.Unit.id B0.Fmt.t -> B0.Unit.t B0.Fmt.t     end   module Idmap :     sig       type +'a t       val empty : 'a t       val is_empty : 'a t -> bool       val mem : id -> 'a t -> bool       val add : id -> '-> 'a t -> 'a t       val singleton : id -> '-> 'a t       val remove : id -> 'a t -> 'a t       val merge :         (id -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t       val union : (id -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t       val compare : ('-> '-> int) -> 'a t -> 'a t -> int       val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool       val iter : (id -> '-> unit) -> 'a t -> unit       val fold : (id -> '-> '-> 'b) -> 'a t -> '-> 'b       val for_all : (id -> '-> bool) -> 'a t -> bool       val exists : (id -> '-> bool) -> 'a t -> bool       val filter : (id -> '-> bool) -> 'a t -> 'a t       val partition : (id -> '-> bool) -> 'a t -> 'a t * 'a t       val cardinal : 'a t -> int       val bindings : 'a t -> (id * 'a) list       val min_binding : 'a t -> id * 'a       val max_binding : 'a t -> id * 'a       val choose : 'a t -> id * 'a       val split : id -> 'a t -> 'a t * 'a option * 'a t       val find : id -> 'a t -> 'a       val map : ('-> 'b) -> 'a t -> 'b t       val mapi : (id -> '-> 'b) -> 'a t -> 'b t       val pp :         ?sep:unit B0.Fmt.t ->         (B0.Unit.id * 'a) B0.Fmt.t -> 'B0.Unit.t B0.Fmt.t     end   type set   module Set :     sig       val empty : set       val is_empty : set -> bool       val mem : t -> set -> bool       val add : t -> set -> set       val singleton : t -> set       val remove : t -> set -> set       val union : set -> set -> set       val inter : set -> set -> set       val diff : set -> set -> set       val compare : set -> set -> int       val equal : set -> set -> bool       val subset : set -> set -> bool       val iter : (t -> unit) -> set -> unit       val fold : (t -> '-> 'a) -> set -> '-> 'a       val for_all : (t -> bool) -> set -> bool       val exists : (t -> bool) -> set -> bool       val filter : (t -> bool) -> set -> set       val partition : (t -> bool) -> set -> set * set       val cardinal : set -> int       val elements : set -> t list       val min_elt : set -> t       val max_elt : set -> t       val choose : set -> t       val split : t -> set -> set * bool * set       val find : t -> set -> t       val of_list : t list -> set       val pp :         ?sep:unit B0.Fmt.t -> B0.Unit.t B0.Fmt.t -> B0.Unit.set B0.Fmt.t       type t = B0.Unit.set     end   type +'a map   module Map :     sig       val empty : 'a map       val is_empty : 'a map -> bool       val mem : t -> 'a map -> bool       val add : t -> '-> 'a map -> 'a map       val singleton : t -> '-> 'a map       val remove : t -> 'a map -> 'a map       val merge :         (t -> 'a option -> 'b option -> 'c option) ->         'a map -> 'b map -> 'c map       val union : (t -> '-> '-> 'a option) -> 'a map -> 'a map -> 'a map       val compare : ('-> '-> int) -> 'a map -> 'a map -> int       val equal : ('-> '-> bool) -> 'a map -> 'a map -> bool       val iter : (t -> '-> unit) -> 'a map -> unit       val fold : (t -> '-> '-> 'b) -> 'a map -> '-> 'b       val for_all : (t -> '-> bool) -> 'a map -> bool       val exists : (t -> '-> bool) -> 'a map -> bool       val filter : (t -> '-> bool) -> 'a map -> 'a map       val partition : (t -> '-> bool) -> 'a map -> 'a map * 'a map       val cardinal : 'a map -> int       val bindings : 'a map -> (t * 'a) list       val min_binding : 'a map -> t * 'a       val max_binding : 'a map -> t * 'a       val choose : 'a map -> t * 'a       val split : t -> 'a map -> 'a map * 'a option * 'a map       val find : t -> 'a map -> 'a       val map : ('-> 'b) -> 'a map -> 'b map       val mapi : (t -> '-> 'b) -> 'a map -> 'b map       val of_list : (B0.Unit.t * 'a) list -> 'B0.Unit.map       val pp :         ?sep:unit B0.Fmt.t ->         (B0.Unit.t * 'a) B0.Fmt.t -> 'B0.Unit.map B0.Fmt.t       type 'a t = 'B0.Unit.map       val dom : 'B0.Unit.map -> B0.Unit.set     end end