sig   type ('a, 'b) result = ('a, 'b) Rresult.result = Ok of '| Error of 'b   val ( >>= ) :     ('a, 'b) Result.result ->     ('-> ('c, 'b) Result.result) -> ('c, 'b) Result.result   val ( >>| ) :     ('a, 'b) Result.result -> ('-> 'c) -> ('c, 'b) Result.result   module R :     sig       type ('a, 'b) t = ('a, 'b) Result.result       val ok : '-> ('a, 'b) Result.result       val error : '-> ('a, 'b) Result.result       val reword_error :         ('-> 'c) -> ('a, 'b) Result.result -> ('a, 'c) Result.result       val get_ok : ('a, 'b) Result.result -> 'a       val get_error : ('a, 'b) Result.result -> 'b       val return : '-> ('a, 'b) Result.result       val fail : '-> ('a, 'b) Result.result       val bind :         ('a, 'b) Result.result ->         ('-> ('c, 'b) Result.result) -> ('c, 'b) Result.result       val map :         ('-> 'c) -> ('a, 'b) Result.result -> ('c, 'b) Result.result       val join :         (('a, 'b) Result.result, 'b) Result.result -> ('a, 'b) Result.result       val ( >>= ) :         ('a, 'b) Result.result ->         ('-> ('c, 'b) Result.result) -> ('c, 'b) Result.result       val ( >>| ) :         ('a, 'b) Result.result -> ('-> 'c) -> ('c, 'b) Result.result       module Infix :         sig           val ( >>= ) :             ('a, 'b) Result.result ->             ('-> ('c, 'b) Result.result) -> ('c, 'b) Result.result           val ( >>| ) :             ('a, 'b) Result.result -> ('-> 'c) -> ('c, 'b) Result.result         end       type msg = [ `Msg of string ]       val msg : string -> [> msg ]       val msgf : ('a, Format.formatter, unit, [> msg ]) format4 -> 'a       val pp_msg : Format.formatter -> msg -> unit       val error_msg : string -> ('a, [> msg ]) Result.result       val error_msgf :         ('a, Format.formatter, unit, ('b, [> msg ]) Result.result) format4 ->         'a       val reword_error_msg :         ?replace:bool ->         (string -> msg) ->         ('a, msg) Result.result -> ('a, [> msg ]) Result.result       val error_to_msg :         pp_error:(Format.formatter -> '-> unit) ->         ('a, 'b) Result.result -> ('a, [> msg ]) Result.result       val error_msg_to_invalid_arg : ('a, msg) Result.result -> 'a       val open_error_msg :         ('a, msg) Result.result -> ('a, [> msg ]) Result.result       type exn_trap = [ `Exn_trap of exn * Printexc.raw_backtrace ]       val pp_exn_trap : Format.formatter -> exn_trap -> unit       val trap_exn : ('-> 'b) -> '-> ('b, [> exn_trap ]) Result.result       val error_exn_trap_to_msg :         ('a, exn_trap) Result.result -> ('a, [> msg ]) Result.result       val open_error_exn_trap :         ('a, exn_trap) Result.result -> ('a, [> exn_trap ]) Result.result       val pp :         ok:(Format.formatter -> '-> unit) ->         error:(Format.formatter -> '-> unit) ->         Format.formatter -> ('a, 'b) Result.result -> unit       val dump :         ok:(Format.formatter -> '-> unit) ->         error:(Format.formatter -> '-> unit) ->         Format.formatter -> ('a, 'b) Result.result -> unit       val is_ok : ('a, 'b) Result.result -> bool       val is_error : ('a, 'b) Result.result -> bool       val equal :         ok:('-> '-> bool) ->         error:('-> '-> bool) ->         ('a, 'b) Result.result -> ('a, 'b) Result.result -> bool       val compare :         ok:('-> '-> int) ->         error:('-> '-> int) ->         ('a, 'b) Result.result -> ('a, 'b) Result.result -> int       val to_option : ('a, 'b) Result.result -> 'a option       val of_option :         none:(unit -> ('a, 'b) Result.result) ->         'a option -> ('a, 'b) Result.result       val to_presult :         ('a, 'b) Result.result -> [> `Error of '| `Ok of 'a ]       val of_presult :         [< `Error of '| `Ok of 'a ] -> ('a, 'b) Result.result       val ignore_error : use:'-> ('a, 'b) Result.result -> 'a       val kignore_error :         use:('a, 'c) Result.result ->         ('a, 'b) Result.result -> ('a, 'c) Result.result     end   val strf : ('a, Format.formatter, unit, string) Pervasives.format4 -> 'a   val ( ^ ) : string -> string -> string   module Char :     sig       type t = char       val of_byte : int -> char       val unsafe_of_byte : int -> char       val of_int : int -> char option       val to_int : char -> int       val hash : char -> int       val equal : char -> char -> bool       val compare : char -> char -> int       module Ascii :         sig           val is_valid : char -> bool           val is_digit : char -> bool           val is_hex_digit : char -> bool           val is_upper : char -> bool           val is_lower : char -> bool           val is_letter : char -> bool           val is_alphanum : char -> bool           val is_white : char -> bool           val is_blank : char -> bool           val is_graphic : char -> bool           val is_print : char -> bool           val is_control : char -> bool           val uppercase : char -> char           val lowercase : char -> char           val escape : char -> string           val escape_char : char -> string         end       val pp : Format.formatter -> char -> unit       val dump : Format.formatter -> char -> unit     end   module String :     sig       type t = string       val empty : string       val v : len:int -> (int -> char) -> string       val length : string -> int       val get : string -> int -> char       val get_byte : string -> int -> int       val unsafe_get : string -> int -> char       val unsafe_get_byte : string -> int -> int       val head : ?rev:bool -> string -> char option       val get_head : ?rev:bool -> string -> char       val hash : string -> int       val append : string -> string -> string       val concat : ?sep:string -> string list -> string       val is_empty : string -> bool       val is_prefix : affix:string -> string -> bool       val is_infix : affix:string -> string -> bool       val is_suffix : affix:string -> string -> bool       val for_all : (char -> bool) -> string -> bool       val exists : (char -> bool) -> string -> bool       val equal : string -> string -> bool       val compare : string -> string -> int       val with_range : ?first:int -> ?len:int -> string -> string       val with_index_range : ?first:int -> ?last:int -> string -> string       val trim : ?drop:(char -> bool) -> string -> string       val span :         ?rev:bool ->         ?min:int ->         ?max:int -> ?sat:(char -> bool) -> string -> string * string       val take :         ?rev:bool ->         ?min:int -> ?max:int -> ?sat:(char -> bool) -> string -> string       val drop :         ?rev:bool ->         ?min:int -> ?max:int -> ?sat:(char -> bool) -> string -> string       val cut : ?rev:bool -> sep:string -> string -> (string * string) option       val cuts :         ?rev:bool -> ?empty:bool -> sep:string -> string -> string list       val fields :         ?empty:bool -> ?is_sep:(char -> bool) -> string -> string list       type sub = Astring.String.sub       val sub : ?start:int -> ?stop:int -> string -> sub       val sub_with_range : ?first:int -> ?len:int -> string -> sub       val sub_with_index_range : ?first:int -> ?last:int -> string -> sub       module Sub :         sig           type t = Astring.String.sub           val empty : Astring.String.sub           val v : ?start:int -> ?stop:int -> string -> Astring.String.sub           val start_pos : Astring.String.sub -> int           val stop_pos : Astring.String.sub -> int           val base_string : Astring.String.sub -> string           val length : Astring.String.sub -> int           val get : Astring.String.sub -> int -> char           val get_byte : Astring.String.sub -> int -> int           val unsafe_get : Astring.String.sub -> int -> char           val unsafe_get_byte : Astring.String.sub -> int -> int           val head : ?rev:bool -> Astring.String.sub -> char option           val get_head : ?rev:bool -> Astring.String.sub -> char           val of_string : string -> Astring.String.sub           val to_string : Astring.String.sub -> string           val rebase : Astring.String.sub -> Astring.String.sub           val hash : Astring.String.sub -> int           val start : Astring.String.sub -> Astring.String.sub           val stop : Astring.String.sub -> Astring.String.sub           val base : Astring.String.sub -> Astring.String.sub           val tail : ?rev:bool -> Astring.String.sub -> Astring.String.sub           val extend :             ?rev:bool ->             ?max:int ->             ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub           val reduce :             ?rev:bool ->             ?max:int ->             ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub           val extent :             Astring.String.sub -> Astring.String.sub -> Astring.String.sub           val overlap :             Astring.String.sub ->             Astring.String.sub -> Astring.String.sub option           val append :             Astring.String.sub -> Astring.String.sub -> Astring.String.sub           val concat :             ?sep:Astring.String.sub ->             Astring.String.sub list -> Astring.String.sub           val is_empty : Astring.String.sub -> bool           val is_prefix :             affix:Astring.String.sub -> Astring.String.sub -> bool           val is_infix :             affix:Astring.String.sub -> Astring.String.sub -> bool           val is_suffix :             affix:Astring.String.sub -> Astring.String.sub -> bool           val for_all : (char -> bool) -> Astring.String.sub -> bool           val exists : (char -> bool) -> Astring.String.sub -> bool           val same_base : Astring.String.sub -> Astring.String.sub -> bool           val equal_bytes : Astring.String.sub -> Astring.String.sub -> bool           val compare_bytes : Astring.String.sub -> Astring.String.sub -> int           val equal : Astring.String.sub -> Astring.String.sub -> bool           val compare : Astring.String.sub -> Astring.String.sub -> int           val with_range :             ?first:int ->             ?len:int -> Astring.String.sub -> Astring.String.sub           val with_index_range :             ?first:int ->             ?last:int -> Astring.String.sub -> Astring.String.sub           val trim :             ?drop:(char -> bool) -> Astring.String.sub -> Astring.String.sub           val span :             ?rev:bool ->             ?min:int ->             ?max:int ->             ?sat:(char -> bool) ->             Astring.String.sub -> Astring.String.sub * Astring.String.sub           val take :             ?rev:bool ->             ?min:int ->             ?max:int ->             ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub           val drop :             ?rev:bool ->             ?min:int ->             ?max:int ->             ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub           val cut :             ?rev:bool ->             sep:Astring.String.sub ->             Astring.String.sub ->             (Astring.String.sub * Astring.String.sub) option           val cuts :             ?rev:bool ->             ?empty:bool ->             sep:Astring.String.sub ->             Astring.String.sub -> Astring.String.sub list           val fields :             ?empty:bool ->             ?is_sep:(char -> bool) ->             Astring.String.sub -> Astring.String.sub list           val find :             ?rev:bool ->             (char -> bool) -> Astring.String.sub -> Astring.String.sub option           val find_sub :             ?rev:bool ->             sub:Astring.String.sub ->             Astring.String.sub -> Astring.String.sub option           val filter :             (char -> bool) -> Astring.String.sub -> Astring.String.sub           val filter_map :             (char -> char option) -> Astring.String.sub -> Astring.String.sub           val map :             (char -> char) -> Astring.String.sub -> Astring.String.sub           val mapi :             (int -> char -> char) -> Astring.String.sub -> Astring.String.sub           val fold_left :             ('-> char -> 'a) -> '-> Astring.String.sub -> 'a           val fold_right :             (char -> '-> 'a) -> Astring.String.sub -> '-> 'a           val iter : (char -> unit) -> Astring.String.sub -> unit           val iteri : (int -> char -> unit) -> Astring.String.sub -> unit           val pp : Format.formatter -> Astring.String.sub -> unit           val dump : Format.formatter -> Astring.String.sub -> unit           val dump_raw : Format.formatter -> Astring.String.sub -> unit           val of_char : char -> Astring.String.sub           val to_char : Astring.String.sub -> char option           val of_bool : bool -> Astring.String.sub           val to_bool : Astring.String.sub -> bool option           val of_int : int -> Astring.String.sub           val to_int : Astring.String.sub -> int option           val of_nativeint : nativeint -> Astring.String.sub           val to_nativeint : Astring.String.sub -> nativeint option           val of_int32 : int32 -> Astring.String.sub           val to_int32 : Astring.String.sub -> int32 option           val of_int64 : int64 -> Astring.String.sub           val to_int64 : Astring.String.sub -> int64 option           val of_float : float -> Astring.String.sub           val to_float : Astring.String.sub -> float option         end       val find :         ?rev:bool -> ?start:int -> (char -> bool) -> string -> int option       val find_sub :         ?rev:bool -> ?start:int -> sub:string -> string -> int option       val filter : (char -> bool) -> string -> string       val filter_map : (char -> char option) -> string -> string       val map : (char -> char) -> string -> string       val mapi : (int -> char -> char) -> string -> string       val fold_left : ('-> char -> 'a) -> '-> string -> 'a       val fold_right : (char -> '-> 'a) -> string -> '-> 'a       val iter : (char -> unit) -> string -> unit       val iteri : (int -> char -> unit) -> string -> unit       val uniquify : string list -> string list       module Ascii :         sig           val is_valid : string -> bool           val uppercase : string -> string           val lowercase : string -> string           val capitalize : string -> string           val uncapitalize : string -> string           val escape : string -> string           val unescape : string -> string option           val escape_string : string -> string           val unescape_string : string -> string option         end       val pp : Format.formatter -> string -> unit       val dump : Format.formatter -> string -> unit       type set = Astring.String.set       module Set :         sig           val empty : Astring.String.set           val is_empty : Astring.String.set -> bool           val mem : string -> Astring.String.set -> bool           val add : string -> Astring.String.set -> Astring.String.set           val singleton : string -> Astring.String.set           val remove : string -> Astring.String.set -> Astring.String.set           val union :             Astring.String.set -> Astring.String.set -> Astring.String.set           val inter :             Astring.String.set -> Astring.String.set -> Astring.String.set           val diff :             Astring.String.set -> Astring.String.set -> Astring.String.set           val compare : Astring.String.set -> Astring.String.set -> int           val equal : Astring.String.set -> Astring.String.set -> bool           val subset : Astring.String.set -> Astring.String.set -> bool           val iter : (string -> unit) -> Astring.String.set -> unit           val fold : (string -> '-> 'a) -> Astring.String.set -> '-> 'a           val for_all : (string -> bool) -> Astring.String.set -> bool           val exists : (string -> bool) -> Astring.String.set -> bool           val filter :             (string -> bool) -> Astring.String.set -> Astring.String.set           val partition :             (string -> bool) ->             Astring.String.set -> Astring.String.set * Astring.String.set           val cardinal : Astring.String.set -> int           val elements : Astring.String.set -> string list           val split :             string ->             Astring.String.set ->             Astring.String.set * bool * Astring.String.set           type t = Astring.String.set           val min_elt : Astring.String.set -> string option           val get_min_elt : Astring.String.set -> string           val max_elt : Astring.String.set -> string option           val get_max_elt : Astring.String.set -> string           val choose : Astring.String.set -> string option           val get_any_elt : Astring.String.set -> string           val find : string -> Astring.String.set -> string option           val get : string -> Astring.String.set -> string           val of_list : string list -> Astring.String.set           val pp :             ?sep:(Format.formatter -> unit -> unit) ->             (Format.formatter -> string -> unit) ->             Format.formatter -> Astring.String.set -> unit           val dump : Format.formatter -> Astring.String.set -> unit         end       type 'a map = 'Astring.String.map       module Map :         sig           val empty : 'Astring.String.map           val is_empty : 'Astring.String.map -> bool           val mem : string -> 'Astring.String.map -> bool           val add :             string -> '-> 'Astring.String.map -> 'Astring.String.map           val singleton : string -> '-> 'Astring.String.map           val remove :             string -> 'Astring.String.map -> 'Astring.String.map           val merge :             (string -> 'a option -> 'b option -> 'c option) ->             'Astring.String.map ->             'Astring.String.map -> 'Astring.String.map           val union :             (string -> '-> '-> 'a option) ->             'Astring.String.map ->             'Astring.String.map -> 'Astring.String.map           val compare :             ('-> '-> int) ->             'Astring.String.map -> 'Astring.String.map -> int           val equal :             ('-> '-> bool) ->             'Astring.String.map -> 'Astring.String.map -> bool           val iter : (string -> '-> unit) -> 'Astring.String.map -> unit           val fold :             (string -> '-> '-> 'b) -> 'Astring.String.map -> '-> 'b           val for_all :             (string -> '-> bool) -> 'Astring.String.map -> bool           val exists :             (string -> '-> bool) -> 'Astring.String.map -> bool           val filter :             (string -> '-> bool) ->             'Astring.String.map -> 'Astring.String.map           val partition :             (string -> '-> bool) ->             'Astring.String.map ->             'Astring.String.map * 'Astring.String.map           val cardinal : 'Astring.String.map -> int           val bindings : 'Astring.String.map -> (string * 'a) list           val split :             string ->             'Astring.String.map ->             'Astring.String.map * 'a option * 'Astring.String.map           val map :             ('-> 'b) -> 'Astring.String.map -> 'Astring.String.map           val mapi :             (string -> '-> 'b) ->             'Astring.String.map -> 'Astring.String.map           type 'a t = 'Astring.String.map           val min_binding : 'Astring.String.map -> (string * 'a) option           val get_min_binding : 'Astring.String.map -> string * 'a           val max_binding : 'Astring.String.map -> (string * 'a) option           val get_max_binding : 'Astring.String.map -> string * 'a           val choose : 'Astring.String.map -> (string * 'a) option           val get_any_binding : 'Astring.String.map -> string * 'a           val find : string -> 'Astring.String.map -> 'a option           val get : string -> 'Astring.String.map -> 'a           val dom : 'Astring.String.map -> Astring.String.set           val of_list : (string * 'a) list -> 'Astring.String.map           val pp :             ?sep:(Format.formatter -> unit -> unit) ->             (Format.formatter -> string * '-> unit) ->             Format.formatter -> 'Astring.String.map -> unit           val dump :             (Format.formatter -> '-> unit) ->             Format.formatter -> 'Astring.String.map -> unit           val dump_string_map :             Format.formatter -> string Astring.String.map -> unit         end       val of_char : char -> string       val to_char : string -> char option       val of_bool : bool -> string       val to_bool : string -> bool option       val of_int : int -> string       val to_int : string -> int option       val of_nativeint : nativeint -> string       val to_nativeint : string -> nativeint option       val of_int32 : int32 -> string       val to_int32 : string -> int32 option       val of_int64 : int64 -> string       val to_int64 : string -> int64 option       val of_float : float -> string       val to_float : string -> float option     end   module Pat :     sig       type t = Bos.Pat.t       val v : string -> t       val empty : t       val dom : t -> Astring.String.Set.t       val equal : t -> t -> bool       val compare : t -> t -> int       val of_string : string -> (t, [> Rresult.R.msg ]) Result.result       val to_string : t -> string       val pp : Format.formatter -> t -> unit       val dump : Format.formatter -> t -> unit       type defs = string Astring.String.Map.t       val subst : ?undef:(string -> string option) -> defs -> t -> t       val format : ?undef:(string -> string) -> defs -> t -> string       val matches : t -> string -> bool       val query : ?init:defs -> t -> string -> defs option     end   module Cmd :     sig       type t = Bos.Cmd.t       val v : string -> t       val empty : t       val is_empty : t -> bool       val ( % ) : t -> string -> t       val ( %% ) : t -> t -> t       val add_arg : t -> string -> t       val add_args : t -> t -> t       val on : bool -> t -> t       val p : Fpath.t -> string       val line_exec : t -> string option       val get_line_exec : t -> string       val line_args : t -> string list       val equal : t -> t -> bool       val compare : t -> t -> int       val of_string : string -> (t, Rresult.R.msg) Rresult.result       val to_string : t -> string       val to_list : t -> string list       val of_list : ?slip:string -> string list -> t       val of_values : ?slip:string -> ('-> string) -> 'a list -> t       val pp : Format.formatter -> t -> unit       val dump : Format.formatter -> t -> unit     end   module OS :     sig       type ('a, 'e) result = ('a, 'e) Result.result         constraint 'e = [> Rresult.R.msg ]       module Env :         sig           type t = string Astring.String.map           val current : unit -> (t, [> Rresult.R.msg ]) Bos.OS.result           val var : string -> string option           val set_var :             string ->             string option -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val opt_var : string -> absent:string -> string           val req_var : string -> (string, [> Rresult.R.msg ]) Bos.OS.result           type 'parser = string -> ('a, Rresult.R.msg) Result.result           val parser : string -> (string -> 'a option) -> 'parser           val bool : bool parser           val string : string parser           val path : Fpath.t parser           val cmd : Bos.Cmd.t parser           val some : 'parser -> 'a option parser           val parse :             string ->             'parser -> absent:'-> ('a, [> Rresult.R.msg ]) Bos.OS.result           val value :             ?log:Logs.level -> string -> 'parser -> absent:'-> 'a         end       module Arg :         sig           val exec : string           type 'a conv = 'Bos.OS.Arg.conv           val conv :             ?docv:string ->             (string -> ('a, Rresult.R.msg) Result.result) ->             (Format.formatter -> '-> unit) -> 'a conv           val conv_parser :             'a conv -> string -> ('a, Rresult.R.msg) Result.result           val conv_printer : 'a conv -> Format.formatter -> '-> unit           val conv_docv : 'a conv -> string           val parser_of_kind_of_string :             kind:string ->             (string -> 'a option) ->             string -> ('a, Rresult.R.msg) Result.result           val some : ?none:string -> 'a conv -> 'a option conv           val flag : ?doc:string -> ?env:string -> string list -> bool           val flag_all : ?doc:string -> ?env:string -> string list -> int           val opt :             ?docv:string ->             ?doc:string ->             ?env:string -> string list -> 'a conv -> absent:'-> 'a           val opt_all :             ?docv:string ->             ?doc:string ->             ?env:string ->             string list -> 'a conv -> absent:'a list -> 'a list           val parse_opts : ?doc:string -> ?usage:string -> unit -> unit           val parse :             ?doc:string -> ?usage:string -> pos:'a conv -> unit -> 'a list           val string : string conv           val path : Fpath.t conv           val bin : Bos.Cmd.t conv           val cmd : Bos.Cmd.t conv           val char : char conv           val bool : bool conv           val int : int conv           val nativeint : nativeint conv           val int32 : int32 conv           val int64 : int64 conv           val float : float conv           val enum : (string * 'a) list -> 'a conv           val list : ?sep:string -> 'a conv -> 'a list conv           val array : ?sep:string -> 'a conv -> 'a array conv           val pair : ?sep:string -> 'a conv -> 'b conv -> ('a * 'b) conv         end       module Path :         sig           val exists : Fpath.t -> (bool, [> Rresult.R.msg ]) Bos.OS.result           val must_exist :             Fpath.t -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val move :             ?force:bool ->             Fpath.t -> Fpath.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val delete :             ?must_exist:bool ->             ?recurse:bool ->             Fpath.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val stat :             Fpath.t -> (Unix.stats, [> Rresult.R.msg ]) Bos.OS.result           module Mode :             sig               type t = int               val get : Fpath.t -> (t, [> Rresult.R.msg ]) Bos.OS.result               val set :                 Fpath.t -> t -> (unit, [> Rresult.R.msg ]) Bos.OS.result             end           val link :             ?force:bool ->             target:Fpath.t ->             Fpath.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val symlink :             ?force:bool ->             target:Fpath.t ->             Fpath.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val symlink_target :             Fpath.t -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val symlink_stat :             Fpath.t -> (Unix.stats, [> Rresult.R.msg ]) Bos.OS.result           val matches :             ?dotfiles:bool ->             Fpath.t -> (Fpath.t list, [> Rresult.R.msg ]) Bos.OS.result           val query :             ?dotfiles:bool ->             ?init:Bos.Pat.defs ->             Fpath.t ->             ((Fpath.t * Bos.Pat.defs) list, [> Rresult.R.msg ]) Bos.OS.result           type traverse =               [ `Any               | `None               | `Sat of Fpath.t -> (bool, Rresult.R.msg) Bos.OS.result ]           type elements =               [ `Any               | `Dirs               | `Files               | `Sat of Fpath.t -> (bool, Rresult.R.msg) Bos.OS.result ]           type 'a fold_error =               Fpath.t ->               ('a, Rresult.R.msg) Bos.OS.result ->               (unit, Rresult.R.msg) Bos.OS.result           val log_fold_error : level:Logs.level -> 'a fold_error           val fold :             ?err:'b fold_error ->             ?dotfiles:bool ->             ?elements:elements ->             ?traverse:traverse ->             (Fpath.t -> '-> 'a) ->             '-> Fpath.t list -> ('a, [> Rresult.R.msg ]) Bos.OS.result         end       module File :         sig           val null : Fpath.t           val dash : Fpath.t           val exists : Fpath.t -> (bool, [> Rresult.R.msg ]) Bos.OS.result           val must_exist :             Fpath.t -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val delete :             ?must_exist:bool ->             Fpath.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val truncate :             Fpath.t -> int -> (unit, [> Rresult.R.msg ]) Bos.OS.result           type input = unit -> (Bytes.t * int * int) option           val with_input :             Fpath.t ->             (input -> '-> 'b) ->             '-> ('b, [> Rresult.R.msg ]) Bos.OS.result           val with_ic :             Fpath.t ->             (in_channel -> '-> 'b) ->             '-> ('b, [> Rresult.R.msg ]) Bos.OS.result           val read : Fpath.t -> (string, [> Rresult.R.msg ]) Bos.OS.result           val read_lines :             Fpath.t -> (string list, [> Rresult.R.msg ]) Bos.OS.result           val fold_lines :             ('-> string -> 'a) ->             '-> Fpath.t -> ('a, [> Rresult.R.msg ]) Bos.OS.result           type output = (Bytes.t * int * int) option -> unit           val with_output :             ?mode:int ->             Fpath.t ->             (output -> '-> ('c, 'd) Result.result) ->             '-> (('c, 'd) Result.result, [> Rresult.R.msg ]) Bos.OS.result           val with_oc :             ?mode:int ->             Fpath.t ->             (out_channel -> '-> ('c, 'd) Result.result) ->             '-> (('c, 'd) Result.result, [> Rresult.R.msg ]) Bos.OS.result           val write :             ?mode:int ->             Fpath.t -> string -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val writef :             ?mode:int ->             Fpath.t ->             ('a, Format.formatter, unit,              (unit, [> Rresult.R.msg ]) Bos.OS.result)             format4 -> 'a           val write_lines :             ?mode:int ->             Fpath.t ->             string list -> (unit, [> Rresult.R.msg ]) Bos.OS.result           type tmp_name_pat =               (string -> string, Format.formatter, unit, string) format4           val tmp :             ?mode:int ->             ?dir:Fpath.t ->             tmp_name_pat -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val with_tmp_output :             ?mode:int ->             ?dir:Fpath.t ->             tmp_name_pat ->             (Fpath.t -> output -> '-> 'b) ->             '-> ('b, [> Rresult.R.msg ]) Bos.OS.result           val with_tmp_oc :             ?mode:int ->             ?dir:Fpath.t ->             tmp_name_pat ->             (Fpath.t -> out_channel -> '-> 'b) ->             '-> ('b, [> Rresult.R.msg ]) Bos.OS.result         end       module Dir :         sig           val exists : Fpath.t -> (bool, [> Rresult.R.msg ]) Bos.OS.result           val must_exist :             Fpath.t -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val create :             ?path:bool ->             ?mode:int -> Fpath.t -> (bool, [> Rresult.R.msg ]) Bos.OS.result           val delete :             ?must_exist:bool ->             ?recurse:bool ->             Fpath.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val contents :             ?dotfiles:bool ->             ?rel:bool ->             Fpath.t -> (Fpath.t list, [> Rresult.R.msg ]) Bos.OS.result           val fold_contents :             ?err:'Bos.OS.Path.fold_error ->             ?dotfiles:bool ->             ?elements:Bos.OS.Path.elements ->             ?traverse:Bos.OS.Path.traverse ->             (Fpath.t -> '-> 'a) ->             '-> Fpath.t -> ('a, [> Rresult.R.msg ]) Bos.OS.result           val user : unit -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val current : unit -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val set_current :             Fpath.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val with_current :             Fpath.t ->             ('-> 'b) -> '-> ('b, [> Rresult.R.msg ]) Bos.OS.result           type tmp_name_pat =               (string -> string, Format.formatter, unit, string) format4           val tmp :             ?mode:int ->             ?dir:Fpath.t ->             tmp_name_pat -> (Fpath.t, [> Rresult.R.msg ]) Bos.OS.result           val with_tmp :             ?mode:int ->             ?dir:Fpath.t ->             tmp_name_pat ->             (Fpath.t -> '-> 'b) ->             '-> ('b, [> Rresult.R.msg ]) Bos.OS.result           val default_tmp : unit -> Fpath.t           val set_default_tmp : Fpath.t -> unit         end       module Cmd :         sig           val exists : Bos.Cmd.t -> (bool, [> Rresult.R.msg ]) Bos.OS.result           val must_exist :             Bos.Cmd.t -> (Bos.Cmd.t, [> Rresult.R.msg ]) Bos.OS.result           type status = [ `Exited of int | `Signaled of int ]           val pp_status : status Fmt.t           type run_info = Bos.OS.Cmd.run_info           val run_info_cmd : run_info -> Bos.Cmd.t           type run_status = run_info * status           val success :             ('a * run_status, [> Rresult.R.msg ] as 'b) Bos.OS.result ->             ('a, 'b) Bos.OS.result           type run_err = Bos.OS.Cmd.run_err           val err_file : ?append:bool -> Fpath.t -> run_err           val err_null : run_err           val err_run_out : run_err           val err_stderr : run_err           type run_in = Bos.OS.Cmd.run_in           val in_string : string -> run_in           val in_file : Fpath.t -> run_in           val in_null : run_in           val in_stdin : run_in           type run_out = Bos.OS.Cmd.run_out           val out_string :             ?trim:bool ->             run_out ->             (string * run_status, [> Rresult.R.msg ]) Bos.OS.result           val out_lines :             ?trim:bool ->             run_out ->             (string list * run_status, [> Rresult.R.msg ]) Bos.OS.result           val out_file :             ?append:bool ->             Fpath.t ->             run_out -> (unit * run_status, [> Rresult.R.msg ]) Bos.OS.result           val out_run_in :             run_out -> (run_in, [> Rresult.R.msg ]) Bos.OS.result           val out_null :             run_out -> (unit * run_status, [> Rresult.R.msg ]) Bos.OS.result           val out_stdout :             run_out -> (unit * run_status, [> Rresult.R.msg ]) Bos.OS.result           val to_string :             ?trim:bool ->             run_out -> (string, [> Rresult.R.msg ]) Bos.OS.result           val to_lines :             ?trim:bool ->             run_out -> (string list, [> Rresult.R.msg ]) Bos.OS.result           val to_file :             ?append:bool ->             Fpath.t -> run_out -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val to_null : run_out -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val to_stdout : run_out -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val run_io :             ?env:Bos.OS.Env.t ->             ?err:run_err -> Bos.Cmd.t -> run_in -> run_out           val run_out :             ?env:Bos.OS.Env.t -> ?err:run_err -> Bos.Cmd.t -> run_out           val run_in :             ?env:Bos.OS.Env.t ->             ?err:run_err ->             Bos.Cmd.t -> run_in -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val run :             ?env:Bos.OS.Env.t ->             ?err:run_err ->             Bos.Cmd.t -> (unit, [> Rresult.R.msg ]) Bos.OS.result           val run_status :             ?env:Bos.OS.Env.t ->             ?err:run_err ->             ?quiet:bool ->             Bos.Cmd.t -> (status, [> Rresult.R.msg ]) Bos.OS.result         end       module U :         sig           type 'a result = ('a, [ `Unix of Unix.error ]) Result.result           val pp_error : Format.formatter -> [ `Unix of Unix.error ] -> unit           val open_error :             'a result -> ('a, [> `Unix of Unix.error ]) Result.result           val error_to_msg :             'a result -> ('a, [> Rresult.R.msg ]) Result.result           val call : ('-> 'b) -> '-> 'b result           val mkdir : Fpath.t -> Unix.file_perm -> unit result           val link : Fpath.t -> Fpath.t -> unit result           val unlink : Fpath.t -> unit result           val rename : Fpath.t -> Fpath.t -> unit result           val stat : Fpath.t -> Unix.stats result           val lstat : Fpath.t -> Unix.stats result           val truncate : Fpath.t -> int -> unit result         end     end   module Fmt :     sig       val pf : Format.formatter -> ('a, Format.formatter, unit) format -> 'a       val kpf :         (Format.formatter -> 'a) ->         Format.formatter -> ('b, Format.formatter, unit, 'a) format4 -> 'b       val strf : ('a, Format.formatter, unit, string) format4 -> 'a       val kstrf :         (string -> 'a) -> ('b, Format.formatter, unit, 'a) format4 -> 'b       val strf_like :         Format.formatter ->         ('a, Format.formatter, unit, string) format4 -> 'a       val with_buffer :         ?like:Format.formatter -> Buffer.t -> Format.formatter       val stdout : Format.formatter       val stderr : Format.formatter       val pr : ('a, Format.formatter, unit) format -> 'a       val epr : ('a, Format.formatter, unit) format -> 'a       type 'a t = Format.formatter -> '-> unit       val nop : 'a t       val cut : unit t       val sp : unit t       val const : 'a t -> '-> unit t       val unit : (unit, Format.formatter, unit) format -> unit t       val fmt : ('a, Format.formatter, unit) format -> Format.formatter -> 'a       val always : (unit, Format.formatter, unit) format -> 'a t       val bool : bool t       val int : int t       val nativeint : nativeint t       val int32 : int32 t       val int64 : int64 t       val uint : int t       val unativeint : nativeint t       val uint32 : int32 t       val uint64 : int64 t       val float : float t       val float_dfrac : int -> float t       val float_dsig : int -> float t       val char : char t       val string : string t       val buffer : Buffer.t t       val exn : exn t       val exn_backtrace : (exn * Printexc.raw_backtrace) t       val pair : ?sep:unit t -> 'a t -> 'b t -> ('a * 'b) t       val option : ?none:unit t -> 'a t -> 'a option t       val result : ok:'a t -> error:'b t -> ('a, 'b) Result.result t       val list : ?sep:unit t -> 'a t -> 'a list t       val array : ?sep:unit t -> 'a t -> 'a array t       val hashtbl : ?sep:unit t -> ('a * 'b) t -> ('a, 'b) Hashtbl.t t       val queue : ?sep:unit t -> 'a t -> 'Queue.t t       val stack : ?sep:unit t -> 'a t -> 'Stack.t t       val iter : ?sep:unit t -> (('-> unit) -> '-> unit) -> 'a t -> 'b t       val iter_bindings :         ?sep:unit t ->         (('-> '-> unit) -> '-> unit) -> ('a * 'b) t -> 'c t       val using : ('-> 'b) -> 'b t -> 'a t       module Dump :         sig           val signal : int Fmt.t           val pair : 'Fmt.t -> 'Fmt.t -> ('a * 'b) Fmt.t           val option : 'Fmt.t -> 'a option Fmt.t           val result :             ok:'Fmt.t -> error:'Fmt.t -> ('a, 'b) Result.result Fmt.t           val list : 'Fmt.t -> 'a list Fmt.t           val array : 'Fmt.t -> 'a array Fmt.t           val hashtbl : 'Fmt.t -> 'Fmt.t -> ('a, 'b) Hashtbl.t Fmt.t           val queue : 'Fmt.t -> 'Queue.t Fmt.t           val stack : 'Fmt.t -> 'Stack.t Fmt.t           val iter :             (('-> unit) -> '-> unit) -> 'Fmt.t -> 'Fmt.t -> 'Fmt.t           val iter_bindings :             (('-> '-> unit) -> '-> unit) ->             'Fmt.t -> 'Fmt.t -> 'Fmt.t -> 'Fmt.t         end       val box : ?indent:int -> 'a t -> 'a t       val hbox : 'a t -> 'a t       val vbox : ?indent:int -> 'a t -> 'a t       val hvbox : ?indent:int -> 'a t -> 'a t       val parens : 'a t -> 'a t       val brackets : 'a t -> 'a t       val braces : 'a t -> 'a t       val quote : ?mark:string -> 'a t -> 'a t       val words : string t       val paragraphs : string t       val text : string t       val lines : string t       val text_loc : ((int * int) * (int * int)) t       val append : 'a t -> 'b t -> ('a * 'b) t       val prefix : unit t -> 'a t -> 'a t       val suffix : unit t -> 'a t -> 'a t       val byte_size : int t       val bi_byte_size : int t       val if_utf_8 : 'a t -> 'a t -> 'a t       val utf_8 : Format.formatter -> bool       val set_utf_8 : Format.formatter -> bool -> unit       type style =           [ `Black           | `Blue           | `Bold           | `Cyan           | `Green           | `Magenta           | `None           | `Red           | `Underline           | `White           | `Yellow ]       val styled : style -> 'a t -> 'a t       val styled_unit :         style -> (unit, Format.formatter, unit) format -> unit t       type style_renderer = [ `Ansi_tty | `None ]       val style_renderer : Format.formatter -> style_renderer       val set_style_renderer : Format.formatter -> style_renderer -> unit       val of_to_string : ('-> string) -> 'a t       val to_to_string : 'a t -> '-> string     end   module Logs :     sig       type level = Logs.level = App | Error | Warning | Info | Debug       val level : unit -> level option       val set_level : ?all:bool -> level option -> unit       val pp_level : Format.formatter -> level -> unit       val level_to_string : level option -> string       val level_of_string :         string -> (level option, [ `Msg of string ]) Result.result       type src = Logs.src       val default : src       module Src :         sig           type t = Logs.src           val create : ?doc:string -> string -> Logs.src           val name : Logs.src -> string           val doc : Logs.src -> string           val level : Logs.src -> Logs.level option           val set_level : Logs.src -> Logs.level option -> unit           val equal : Logs.src -> Logs.src -> bool           val compare : Logs.src -> Logs.src -> int           val pp : Format.formatter -> Logs.src -> unit           val list : unit -> Logs.src list         end       module Tag :         sig           type 'a def = 'Logs.Tag.def           type def_e = Logs.Tag.def_e = Def : 'a def -> def_e           val def :             ?doc:string ->             string -> (Format.formatter -> '-> unit) -> 'a def           val name : 'a def -> string           val doc : 'a def -> string           val printer : 'a def -> Format.formatter -> '-> unit           val pp_def : Format.formatter -> 'a def -> unit           val list : unit -> def_e list           type t = Logs.Tag.t = V : 'a def * '-> t           val pp : Format.formatter -> t -> unit           type set = Logs.Tag.set           val empty : set           val is_empty : set -> bool           val mem : 'a def -> set -> bool           val add : 'a def -> '-> set -> set           val rem : 'a def -> set -> set           val find : 'a def -> set -> 'a option           val get : 'a def -> set -> 'a           val fold : (t -> '-> 'a) -> set -> '-> 'a           val pp_set : Format.formatter -> set -> unit         end       type ('a, 'b) msgf =           (?header:string ->            ?tags:Tag.set -> ('a, Format.formatter, unit, 'b) format4 -> 'a) ->           'b       type 'a log = ('a, unit) msgf -> unit       val msg : ?src:src -> level -> 'a log       val app : ?src:src -> 'a log       val err : ?src:src -> 'a log       val warn : ?src:src -> 'a log       val info : ?src:src -> 'a log       val debug : ?src:src -> 'a log       val kmsg : (unit -> 'b) -> ?src:src -> level -> ('a, 'b) msgf -> 'b       val on_error :         ?src:src ->         ?level:level ->         ?header:string ->         ?tags:Tag.set ->         pp:(Format.formatter -> '-> unit) ->         use:('-> 'a) -> ('a, 'b) Result.result -> 'a       val on_error_msg :         ?src:src ->         ?level:level ->         ?header:string ->         ?tags:Tag.set ->         use:(unit -> 'a) -> ('a, [ `Msg of string ]) Result.result -> 'a       module type LOG =         sig           val msg : level -> 'a log           val app : 'a log           val err : 'a log           val warn : 'a log           val info : 'a log           val debug : 'a log           val kmsg : (unit -> 'b) -> level -> ('a, 'b) msgf -> 'b           val on_error :             ?level:level ->             ?header:string ->             ?tags:Tag.set ->             pp:(Format.formatter -> '-> unit) ->             use:('-> 'a) -> ('a, 'b) Result.result -> 'a           val on_error_msg :             ?level:level ->             ?header:string ->             ?tags:Tag.set ->             use:(unit -> 'a) -> ('a, [ `Msg of string ]) Result.result -> 'a         end       val src_log : src -> (module LOG)       type reporter =         Logs.reporter = {         report :           ''b.             src ->             level ->             over:(unit -> unit) -> (unit -> 'b) -> ('a, 'b) msgf -> 'b;       }       val nop_reporter : reporter       val format_reporter :         ?pp_header:(Format.formatter -> level * string option -> unit) ->         ?app:Format.formatter -> ?dst:Format.formatter -> unit -> reporter       val reporter : unit -> reporter       val set_reporter : reporter -> unit       val report :         src ->         level -> over:(unit -> unit) -> (unit -> 'b) -> ('a, 'b) msgf -> 'b       val incr_err_count : unit -> unit       val incr_warn_count : unit -> unit       val pp_print_text : Format.formatter -> string -> unit       val pp_header : Format.formatter -> level * string option -> unit       val err_count : unit -> int       val warn_count : unit -> int     end end