sig   module Monoid :     sig       module type Base =         sig           type t           val zero : Monads.Std.Monoid.Base.t           val plus :             Monads.Std.Monoid.Base.t ->             Monads.Std.Monoid.Base.t -> Monads.Std.Monoid.Base.t         end       module type S =         sig           type t           val zero : t           val plus : t -> t -> t           val concat : t list -> t           val ( @@ ) : t -> t -> t         end       module Make :         functor (M : Base->           sig             val zero : M.t             val plus : M.t -> M.t -> M.t             val concat : M.t list -> M.t             val ( @@ ) : M.t -> M.t -> M.t           end       module Unit :         sig           type t = unit           val zero : t           val plus : t -> t -> t           val concat : t list -> t           val ( @@ ) : t -> t -> t         end       module TList :         functor (T : Core_kernel.Std.T-> sig type t = T.t list end       module Stack :         sig           module Make :             functor (T : Core_kernel.Std.T->               sig                 val zero : TList(T).t                 val plus : TList(T).t -> TList(T).t -> TList(T).t                 val concat : TList(T).t list -> TList(T).t                 val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t               end         end       module List :         sig           module Make :             functor (T : Core_kernel.Std.T->               sig                 val zero : TList(T).t                 val plus : TList(T).t -> TList(T).t -> TList(T).t                 val concat : TList(T).t list -> TList(T).t                 val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t               end         end       module String :         sig           type t = string           val zero : t           val plus : t -> t -> t           val concat : t list -> t           val ( @@ ) : t -> t -> t         end       module Set :         sig           module Make :             functor (S : Core_kernel.Std.Set.S->               sig                 val zero : S.t                 val plus : S.t -> S.t -> S.t                 val concat : S.t list -> S.t                 val ( @@ ) : S.t -> S.t -> S.t               end         end       module Int :         sig           type t = int           val zero : t           val plus : t -> t -> t           val concat : t list -> t           val ( @@ ) : t -> t -> t           module Sum :             sig               type t = int               val zero : t               val plus : t -> t -> t               val concat : t list -> t               val ( @@ ) : t -> t -> t             end           module Product :             sig               type t = Sum.t               val zero : t               val plus : t -> t -> t               val concat : t list -> t               val ( @@ ) : t -> t -> t             end         end       module Float :         sig           type t = float           val zero : t           val plus : t -> t -> t           val concat : t list -> t           val ( @@ ) : t -> t -> t           module Sum :             sig               type t = float               val zero : t               val plus : t -> t -> t               val concat : t list -> t               val ( @@ ) : t -> t -> t             end           module Product :             sig               type t = Sum.t               val zero : t               val plus : t -> t -> t               val concat : t list -> t               val ( @@ ) : t -> t -> t             end         end     end   module Monad :     sig       module Plus :         sig           module type S =             sig               type 'a t               val zero : unit -> 'Monads.Std.Monad.Plus.S.t               val plus :                 'Monads.Std.Monad.Plus.S.t ->                 'Monads.Std.Monad.Plus.S.t -> 'Monads.Std.Monad.Plus.S.t             end           module type S2 =             sig               type ('a, 'e) t               val zero : unit -> ('a, 'e) Monads.Std.Monad.Plus.S2.t               val plus :                 ('a, 'e) Monads.Std.Monad.Plus.S2.t ->                 ('a, 'e) Monads.Std.Monad.Plus.S2.t ->                 ('a, 'e) Monads.Std.Monad.Plus.S2.t             end         end       module Fail :         sig           module type S =             sig               type 'a error               type 'a t               val fail :                 'Monads.Std.Monad.Fail.S.error ->                 'Monads.Std.Monad.Fail.S.t               val catch :                 'Monads.Std.Monad.Fail.S.t ->                 ('Monads.Std.Monad.Fail.S.error ->                  'Monads.Std.Monad.Fail.S.t) ->                 'Monads.Std.Monad.Fail.S.t             end           module type S2 =             sig               type 'a error               type ('a, 'e) t               val fail :                 'Monads.Std.Monad.Fail.S2.error ->                 ('a, 'e) Monads.Std.Monad.Fail.S2.t               val catch :                 ('a, 'e) Monads.Std.Monad.Fail.S2.t ->                 ('Monads.Std.Monad.Fail.S2.error ->                  ('a, 'e) Monads.Std.Monad.Fail.S2.t) ->                 ('a, 'e) Monads.Std.Monad.Fail.S2.t             end         end       module Choice :         sig           module type Basic =             sig               type 'a t               val pure : '-> 'Monads.Std.Monad.Choice.Basic.t               val zero : unit -> 'Monads.Std.Monad.Choice.Basic.t             end           module type S =             sig               type 'a t               val pure : '-> 'a t               val zero : Monoid.Unit.t -> 'a t               val accept : '-> 'Monads.Std.Monad.Choice.S.t               val reject : unit -> 'Monads.Std.Monad.Choice.S.t               val guard : bool -> unit Monads.Std.Monad.Choice.S.t               val on :                 bool ->                 unit Monads.Std.Monad.Choice.S.t ->                 unit Monads.Std.Monad.Choice.S.t               val unless :                 bool ->                 unit Monads.Std.Monad.Choice.S.t ->                 unit Monads.Std.Monad.Choice.S.t             end           module type Basic2 =             sig               type ('a, 'e) t               val pure : '-> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t               val zero : unit -> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t             end           module type S2 =             sig               type ('a, 'e) t               val pure : '-> ('a, 'e) t               val zero : Monoid.Unit.t -> ('a, 'e) t               val accept : '-> ('a, 'e) Monads.Std.Monad.Choice.S2.t               val reject : unit -> ('a, 'e) Monads.Std.Monad.Choice.S2.t               val guard : bool -> (unit, 'e) Monads.Std.Monad.Choice.S2.t               val on :                 bool ->                 (unit, 'e) Monads.Std.Monad.Choice.S2.t ->                 (unit, 'e) Monads.Std.Monad.Choice.S2.t               val unless :                 bool ->                 (unit, 'e) Monads.Std.Monad.Choice.S2.t ->                 (unit, 'e) Monads.Std.Monad.Choice.S2.t             end           module Make :             functor (M : Basic->               sig                 val pure : '-> 'M.t                 val zero : Monoid.Unit.t -> 'M.t                 val accept : '-> 'M.t                 val reject : Monoid.Unit.t -> 'M.t                 val guard : bool -> Monoid.Unit.t M.t                 val on : bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t                 val unless : bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t               end           module Make2 :             functor (M : Basic2->               sig                 val pure : '-> ('a, 'e) M.t                 val zero : Monoid.Unit.t -> ('a, 'e) M.t                 val accept : '-> ('a, 'e) M.t                 val reject : Monoid.Unit.t -> ('a, 'e) M.t                 val guard : bool -> (Monoid.Unit.t, 'e) M.t                 val on :                   bool -> (Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t                 val unless :                   bool -> (Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t               end         end       module Trans :         sig           module type S =             sig               type 'a t               type 'a m               type 'a e               val lift :                 'Monads.Std.Monad.Trans.S.m ->                 'Monads.Std.Monad.Trans.S.t               val run :                 'Monads.Std.Monad.Trans.S.t ->                 'Monads.Std.Monad.Trans.S.e             end           module type S1 =             sig               type ('a, 'e) t               type 'a m               type ('a, 'e) e               val lift :                 'Monads.Std.Monad.Trans.S1.m ->                 ('a, 'e) Monads.Std.Monad.Trans.S1.t               val run :                 ('a, 'e) Monads.Std.Monad.Trans.S1.t ->                 ('a, 'e) Monads.Std.Monad.Trans.S1.e             end           module type S2 =             sig               type ('a, 'e) t               type ('a, 'e) m               type ('a, 'e) e               val lift :                 ('a, 'e) Monads.Std.Monad.Trans.S2.m ->                 ('a, 'e) Monads.Std.Monad.Trans.S2.t               val run :                 ('a, 'e) Monads.Std.Monad.Trans.S2.t ->                 ('a, 'e) Monads.Std.Monad.Trans.S2.e             end         end       module type Basic =         sig           type 'a t           val bind :             'Monads.Std.Monad.Basic.t ->             ('-> 'Monads.Std.Monad.Basic.t) ->             'Monads.Std.Monad.Basic.t           val return : '-> 'Monads.Std.Monad.Basic.t           val map :             [ `Custom of                 'Monads.Std.Monad.Basic.t ->                 f:('-> 'b) -> 'Monads.Std.Monad.Basic.t             | `Define_using_bind ]         end       module type Basic2 =         sig           type ('a, 'e) t           val bind :             ('a, 'e) Monads.Std.Monad.Basic2.t ->             ('-> ('b, 'e) Monads.Std.Monad.Basic2.t) ->             ('b, 'e) Monads.Std.Monad.Basic2.t           val map :             [ `Custom of                 ('a, 'e) Monads.Std.Monad.Basic2.t ->                 f:('-> 'b) -> ('b, 'e) Monads.Std.Monad.Basic2.t             | `Define_using_bind ]           val return : '-> ('a, 'b) Monads.Std.Monad.Basic2.t         end       module Collection :         sig           module type Basic =             sig               type 'a t               val return : '-> 'Monads.Std.Monad.Collection.Basic.t               val zero : Monoid.Unit.t -> 'a t               val plus : 'a t -> 'a t -> 'a t             end           module type Eager =             sig               type 'a t               val return : '-> 'a t               val zero : Monoid.Unit.t -> 'a t               val plus : 'a t -> 'a t -> 'a t               val fold : 'a t -> init:'-> f:('-> '-> 's) -> 's             end           module type Delay =             sig               type 'a t               val return : '-> 'a t               val zero : Monoid.Unit.t -> 'a t               val plus : 'a t -> 'a t -> 'a t               val fold :                 'a t ->                 init:'->                 f:('-> '-> ('-> 'r) -> 'r) -> ('-> 'r) -> 'r             end           module type S2 =             sig               type ('a, 'e) m               type 'a t               val all :                 ('a, 'e) Monads.Std.Monad.Collection.S2.m                 Monads.Std.Monad.Collection.S2.t ->                 ('Monads.Std.Monad.Collection.S2.t, 'e)                 Monads.Std.Monad.Collection.S2.m               val all_ignore :                 ('a, 'e) Monads.Std.Monad.Collection.S2.m                 Monads.Std.Monad.Collection.S2.t ->                 (unit, 'e) Monads.Std.Monad.Collection.S2.m               val sequence :                 (unit, 'e) Monads.Std.Monad.Collection.S2.m                 Monads.Std.Monad.Collection.S2.t ->                 (unit, 'e) Monads.Std.Monad.Collection.S2.m               val map :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('Monads.Std.Monad.Collection.S2.t, 'e)                 Monads.Std.Monad.Collection.S2.m               val iter :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> (unit, 'e) Monads.Std.Monad.Collection.S2.m) ->                 (unit, 'e) Monads.Std.Monad.Collection.S2.m               val fold :                 'Monads.Std.Monad.Collection.S2.t ->                 init:'->                 f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('b, 'e) Monads.Std.Monad.Collection.S2.m               val fold_left :                 'Monads.Std.Monad.Collection.S2.t ->                 init:'->                 f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('b, 'e) Monads.Std.Monad.Collection.S2.m               val fold_right :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->                 init:'-> ('b, 'e) Monads.Std.Monad.Collection.S2.m               val reduce :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> '-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('a option, 'e) Monads.Std.Monad.Collection.S2.m               val exists :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->                 (bool, 'e) Monads.Std.Monad.Collection.S2.m               val for_all :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->                 (bool, 'e) Monads.Std.Monad.Collection.S2.m               val count :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->                 (int, 'e) Monads.Std.Monad.Collection.S2.m               val map_reduce :                 (module Monads.Std.Monoid.S with type t = 'a) ->                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('a, 'e) Monads.Std.Monad.Collection.S2.m               val find :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('a option, 'e) Monads.Std.Monad.Collection.S2.m               val find_map :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('b option, 'e) Monads.Std.Monad.Collection.S2.m               val filter :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('Monads.Std.Monad.Collection.S2.t, 'e)                 Monads.Std.Monad.Collection.S2.m               val filter_map :                 'Monads.Std.Monad.Collection.S2.t ->                 f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->                 ('Monads.Std.Monad.Collection.S2.t, 'e)                 Monads.Std.Monad.Collection.S2.m             end           module type S =             sig               type 'a m               type 'a t               val all :                 'Monads.Std.Monad.Collection.S.m                 Monads.Std.Monad.Collection.S.t ->                 'Monads.Std.Monad.Collection.S.t                 Monads.Std.Monad.Collection.S.m               val all_ignore :                 'Monads.Std.Monad.Collection.S.m                 Monads.Std.Monad.Collection.S.t ->                 unit Monads.Std.Monad.Collection.S.m               val sequence :                 unit Monads.Std.Monad.Collection.S.m                 Monads.Std.Monad.Collection.S.t ->                 unit Monads.Std.Monad.Collection.S.m               val map :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> 'Monads.Std.Monad.Collection.S.m) ->                 'Monads.Std.Monad.Collection.S.t                 Monads.Std.Monad.Collection.S.m               val iter :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> unit Monads.Std.Monad.Collection.S.m) ->                 unit Monads.Std.Monad.Collection.S.m               val fold :                 'Monads.Std.Monad.Collection.S.t ->                 init:'->                 f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->                 'Monads.Std.Monad.Collection.S.m               val fold_left :                 'Monads.Std.Monad.Collection.S.t ->                 init:'->                 f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->                 'Monads.Std.Monad.Collection.S.m               val fold_right :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->                 init:'-> 'Monads.Std.Monad.Collection.S.m               val reduce :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->                 'a option Monads.Std.Monad.Collection.S.m               val exists :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> bool Monads.Std.Monad.Collection.S.m) ->                 bool Monads.Std.Monad.Collection.S.m               val for_all :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> bool Monads.Std.Monad.Collection.S.m) ->                 bool Monads.Std.Monad.Collection.S.m               val count :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> bool Monads.Std.Monad.Collection.S.m) ->                 int Monads.Std.Monad.Collection.S.m               val map_reduce :                 (module Monads.Std.Monoid.S with type t = 'a) ->                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> 'Monads.Std.Monad.Collection.S.m) ->                 'Monads.Std.Monad.Collection.S.m               val find :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> bool Monads.Std.Monad.Collection.S.m) ->                 'a option Monads.Std.Monad.Collection.S.m               val find_map :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->                 'b option Monads.Std.Monad.Collection.S.m               val filter :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> bool Monads.Std.Monad.Collection.S.m) ->                 'Monads.Std.Monad.Collection.S.t                 Monads.Std.Monad.Collection.S.m               val filter_map :                 'Monads.Std.Monad.Collection.S.t ->                 f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->                 'Monads.Std.Monad.Collection.S.t                 Monads.Std.Monad.Collection.S.m             end         end       module Syntax :         sig           module type S =             sig               type 'a t               val ( >>= ) :                 'Monads.Std.Monad.Syntax.S.t ->                 ('-> 'Monads.Std.Monad.Syntax.S.t) ->                 'Monads.Std.Monad.Syntax.S.t               val ( >>| ) :                 'Monads.Std.Monad.Syntax.S.t ->                 ('-> 'b) -> 'Monads.Std.Monad.Syntax.S.t               val ( >=> ) :                 ('-> 'Monads.Std.Monad.Syntax.S.t) ->                 ('-> 'Monads.Std.Monad.Syntax.S.t) ->                 '-> 'Monads.Std.Monad.Syntax.S.t               val ( !! ) : '-> 'Monads.Std.Monad.Syntax.S.t               val ( !$ ) :                 ('-> 'b) ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t               val ( !$$ ) :                 ('-> '-> 'c) ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t               val ( !$$$ ) :                 ('-> '-> '-> 'd) ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t               val ( !$$$$ ) :                 ('-> '-> '-> '-> 'e) ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t               val ( !$$$$$ ) :                 ('-> '-> '-> '-> '-> 'f) ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t ->                 'Monads.Std.Monad.Syntax.S.t             end           module type S2 =             sig               type ('a, 'e) t               val ( >>= ) :                 ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->                 ('b, 'e) Monads.Std.Monad.Syntax.S2.t               val ( >>| ) :                 ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('-> 'b) -> ('b, 'e) Monads.Std.Monad.Syntax.S2.t               val ( >=> ) :                 ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->                 ('-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t) ->                 '-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t               val ( !! ) : '-> ('a, 'e) Monads.Std.Monad.Syntax.S2.t               val ( !$ ) :                 ('-> 'b) ->                 ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('b, 'e) Monads.Std.Monad.Syntax.S2.t               val ( !$$ ) :                 ('-> '-> 'c) ->                 ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('c, 'e) Monads.Std.Monad.Syntax.S2.t               val ( !$$$ ) :                 ('-> '-> '-> 'd) ->                 ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('c, 'e) Monads.Std.Monad.Syntax.S2.t ->                 ('d, 'e) Monads.Std.Monad.Syntax.S2.t               val ( !$$$$ ) :                 ('-> '-> '-> '-> 'e) ->                 ('a, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('b, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('c, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('d, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('e, 's) Monads.Std.Monad.Syntax.S2.t               val ( !$$$$$ ) :                 ('-> '-> '-> '-> '-> 'f) ->                 ('a, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('b, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('c, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('d, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('e, 's) Monads.Std.Monad.Syntax.S2.t ->                 ('f, 's) Monads.Std.Monad.Syntax.S2.t             end         end       module type S =         sig           type 'a t           val void : 'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t           val sequence :             unit Monads.Std.Monad.S.t list -> unit Monads.Std.Monad.S.t           val forever : 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t           module Fn :             sig               val id : '-> 'Monads.Std.Monad.S.t               val ignore :                 'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t               val nothing : unit -> unit Monads.Std.Monad.S.t               val non :                 ('-> bool Monads.Std.Monad.S.t) ->                 '-> bool Monads.Std.Monad.S.t               val apply_n_times :                 n:int ->                 ('-> 'Monads.Std.Monad.S.t) ->                 '-> 'Monads.Std.Monad.S.t               val compose :                 ('-> 'Monads.Std.Monad.S.t) ->                 ('-> 'Monads.Std.Monad.S.t) ->                 '-> 'Monads.Std.Monad.S.t             end           module Pair :             sig               val fst :                 ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t               val snd :                 ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t             end           module Triple :             sig               val fst :                 ('a * 'b * 'c) Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t               val snd :                 ('a * 'b * 'c) Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t               val trd :                 ('a * 'b * 'c) Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t             end           module Lift :             sig               val nullary : '-> 'Monads.Std.Monad.S.t               val unary :                 ('-> 'b) ->                 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t               val binary :                 ('-> '-> 'c) ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t               val ternary :                 ('-> '-> '-> 'd) ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t               val quaternary :                 ('-> '-> '-> '-> 'e) ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t               val quinary :                 ('-> '-> '-> '-> '-> 'f) ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t ->                 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t             end           module Exn :             sig               val expect :                 ?finally:(unit -> unit Monads.Std.Monad.S.t) ->                 f:(unit -> 'Monads.Std.Monad.S.t) ->                 catch:(exn -> 'Monads.Std.Monad.S.t) ->                 'Monads.Std.Monad.S.t             end           module Collection :             sig               module type S =                 sig                   type 'a t                   val all : 'a t t -> 'a t t                   val all_ignore : 'a t t -> Monoid.Unit.t t                   val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t                   val map : 'a t -> f:('-> 'b t) -> 'b t t                   val iter :                     'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                   val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t                   val fold_left :                     'a t -> init:'-> f:('-> '-> 'b t) -> 'b t                   val fold_right :                     'a t -> f:('-> '-> 'b t) -> init:'-> 'b t                   val reduce : 'a t -> f:('-> '-> 'a t) -> 'a option t                   val exists : 'a t -> f:('-> bool t) -> bool t                   val for_all : 'a t -> f:('-> bool t) -> bool t                   val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t                   val map_reduce :                     (module Monoid.S with type t = 'a) ->                     'b t -> f:('-> 'a t) -> 'a t                   val find : 'a t -> f:('-> bool t) -> 'a option t                   val find_map : 'a t -> f:('-> 'b option t) -> 'b option t                   val filter : 'a t -> f:('-> bool t) -> 'a t t                   val filter_map : 'a t -> f:('-> 'b option t) -> 'b t t                 end               module Eager :                 functor (T : Collection.Eager->                   sig                     val all : 'a t T.t -> 'T.t t                     val all_ignore : 'a t T.t -> Monoid.Unit.t t                     val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t                     val map : 'T.t -> f:('-> 'b t) -> 'T.t t                     val iter :                       'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                     val fold :                       'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                     val fold_left :                       'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                     val fold_right :                       'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t                     val reduce :                       'T.t -> f:('-> '-> 'a t) -> 'a option t                     val exists : 'T.t -> f:('-> bool t) -> bool t                     val for_all : 'T.t -> f:('-> bool t) -> bool t                     val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'T.t -> f:('-> 'a t) -> 'a t                     val find : 'T.t -> f:('-> bool t) -> 'a option t                     val find_map :                       'T.t -> f:('-> 'b option t) -> 'b option t                     val filter : 'T.t -> f:('-> bool t) -> 'T.t t                     val filter_map :                       'T.t -> f:('-> 'b option t) -> 'T.t t                   end               module Delay :                 functor (T : Collection.Delay->                   sig                     val all : 'a t T.t -> 'T.t t                     val all_ignore : 'a t T.t -> Monoid.Unit.t t                     val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t                     val map : 'T.t -> f:('-> 'b t) -> 'T.t t                     val iter :                       'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                     val fold :                       'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                     val fold_left :                       'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                     val fold_right :                       'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t                     val reduce :                       'T.t -> f:('-> '-> 'a t) -> 'a option t                     val exists : 'T.t -> f:('-> bool t) -> bool t                     val for_all : 'T.t -> f:('-> bool t) -> bool t                     val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'T.t -> f:('-> 'a t) -> 'a t                     val find : 'T.t -> f:('-> bool t) -> 'a option t                     val find_map :                       'T.t -> f:('-> 'b option t) -> 'b option t                     val filter : 'T.t -> f:('-> bool t) -> 'T.t t                     val filter_map :                       'T.t -> f:('-> 'b option t) -> 'T.t t                   end             end           module List :             sig               val all : 'a t list -> 'a list t               val all_ignore : 'a t list -> Monoid.Unit.t t               val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t               val map : 'a list -> f:('-> 'b t) -> 'b list t               val iter :                 'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t               val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t               val fold_left :                 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t               val fold_right :                 'a list -> f:('-> '-> 'b t) -> init:'-> 'b t               val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t               val exists : 'a list -> f:('-> bool t) -> bool t               val for_all : 'a list -> f:('-> bool t) -> bool t               val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t               val map_reduce :                 (module Monoid.S with type t = 'a) ->                 'b list -> f:('-> 'a t) -> 'a t               val find : 'a list -> f:('-> bool t) -> 'a option t               val find_map : 'a list -> f:('-> 'b option t) -> 'b option t               val filter : 'a list -> f:('-> bool t) -> 'a list t               val filter_map : 'a list -> f:('-> 'b option t) -> 'b list t             end           module Seq :             sig               val all :                 'a t Core_kernel.Std.Sequence.t ->                 'Core_kernel.Std.Sequence.t t               val all_ignore :                 'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t               val sequence :                 Monoid.Unit.t t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t               val map :                 'Core_kernel.Std.Sequence.t ->                 f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t               val iter :                 'Core_kernel.Std.Sequence.t ->                 f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t               val fold :                 'Core_kernel.Std.Sequence.t ->                 init:'-> f:('-> '-> 'b t) -> 'b t               val fold_left :                 'Core_kernel.Std.Sequence.t ->                 init:'-> f:('-> '-> 'b t) -> 'b t               val fold_right :                 'Core_kernel.Std.Sequence.t ->                 f:('-> '-> 'b t) -> init:'-> 'b t               val reduce :                 'Core_kernel.Std.Sequence.t ->                 f:('-> '-> 'a t) -> 'a option t               val exists :                 'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t               val for_all :                 'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t               val count :                 'Core_kernel.Std.Sequence.t ->                 f:('-> bool t) -> Monoid.Int.t t               val map_reduce :                 (module Monoid.S with type t = 'a) ->                 'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t               val find :                 'Core_kernel.Std.Sequence.t ->                 f:('-> bool t) -> 'a option t               val find_map :                 'Core_kernel.Std.Sequence.t ->                 f:('-> 'b option t) -> 'b option t               val filter :                 'Core_kernel.Std.Sequence.t ->                 f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t               val filter_map :                 'Core_kernel.Std.Sequence.t ->                 f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t             end           val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t           val ( !! ) : '-> 'a t           val ( !$ ) : ('-> 'b) -> 'a t -> 'b t           val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t           val ( !$$$ ) :             ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t           val ( !$$$$ ) :             ('-> '-> '-> '-> 'e) ->             'a t -> 'b t -> 'c t -> 'd t -> 'e t           val ( !$$$$$ ) :             ('-> '-> '-> '-> '-> 'f) ->             'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t           val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t           val ( >>| ) : 'a t -> ('-> 'b) -> 'b t           module Monad_infix :             sig               val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t               val ( >>| ) : 'a t -> ('-> 'b) -> 'b t             end           val bind : 'a t -> ('-> 'b t) -> 'b t           val return : '-> 'a t           val map : 'a t -> f:('-> 'b) -> 'b t           val join : 'a t t -> 'a t           val ignore_m : 'a t -> Monoid.Unit.t t           val all : 'a t list -> 'a list t           val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t           module Let_syntax :             sig               module Let_syntax :                 sig                   val return : '-> 'a t                   val bind : 'a t -> ('-> 'b t) -> 'b t                   val map : 'a t -> f:('-> 'b) -> 'b t                   val both : 'a t -> 'b t -> ('a * 'b) t                   module Open_on_rhs : sig val return : '-> 'a t end                   module Open_in_body : sig val return : '-> 'a t end                 end             end           module Syntax :             sig               val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t               val ( >>| ) : 'a t -> ('-> 'b) -> 'b t               val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t               val ( !! ) : '-> 'a t               val ( !$ ) : ('-> 'b) -> 'a t -> 'b t               val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t               val ( !$$$ ) :                 ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t               val ( !$$$$ ) :                 ('-> '-> '-> '-> 'e) ->                 'a t -> 'b t -> 'c t -> 'd t -> 'e t               val ( !$$$$$ ) :                 ('-> '-> '-> '-> '-> 'f) ->                 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t             end         end       module type S2 =         sig           type ('a, 'e) t           val void :             ('a, 'e) Monads.Std.Monad.S2.t ->             (unit, 'e) Monads.Std.Monad.S2.t           val sequence :             (unit, 'e) Monads.Std.Monad.S2.t list ->             (unit, 'e) Monads.Std.Monad.S2.t           val forever :             ('a, 'e) Monads.Std.Monad.S2.t -> ('b, 'e) Monads.Std.Monad.S2.t           module Fn :             sig               val id : '-> ('a, 'e) Monads.Std.Monad.S2.t               val ignore :                 ('a, 'e) Monads.Std.Monad.S2.t ->                 (unit, 'e) Monads.Std.Monad.S2.t               val nothing : unit -> (unit, 'e) Monads.Std.Monad.S2.t               val non :                 ('-> (bool, 'e) Monads.Std.Monad.S2.t) ->                 '-> (bool, 'e) Monads.Std.Monad.S2.t               val apply_n_times :                 n:int ->                 ('-> ('a, 'e) Monads.Std.Monad.S2.t) ->                 '-> ('a, 'e) Monads.Std.Monad.S2.t               val compose :                 ('-> ('c, 'e) Monads.Std.Monad.S2.t) ->                 ('-> ('b, 'e) Monads.Std.Monad.S2.t) ->                 '-> ('c, 'e) Monads.Std.Monad.S2.t             end           module Pair :             sig               val fst :                 ('a * 'b, 'e) Monads.Std.Monad.S2.t ->                 ('a, 'e) Monads.Std.Monad.S2.t               val snd :                 ('a * 'b, 'e) Monads.Std.Monad.S2.t ->                 ('b, 'e) Monads.Std.Monad.S2.t             end           module Triple :             sig               val fst :                 ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->                 ('a, 'e) Monads.Std.Monad.S2.t               val snd :                 ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->                 ('b, 'e) Monads.Std.Monad.S2.t               val trd :                 ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->                 ('c, 'e) Monads.Std.Monad.S2.t             end           module Lift :             sig               val nullary : '-> ('a, 'e) Monads.Std.Monad.S2.t               val unary :                 ('-> 'b) ->                 ('a, 'e) Monads.Std.Monad.S2.t ->                 ('b, 'e) Monads.Std.Monad.S2.t               val binary :                 ('-> '-> 'c) ->                 ('a, 'e) Monads.Std.Monad.S2.t ->                 ('b, 'e) Monads.Std.Monad.S2.t ->                 ('c, 'e) Monads.Std.Monad.S2.t               val ternary :                 ('-> '-> '-> 'd) ->                 ('a, 'e) Monads.Std.Monad.S2.t ->                 ('b, 'e) Monads.Std.Monad.S2.t ->                 ('c, 'e) Monads.Std.Monad.S2.t ->                 ('d, 'e) Monads.Std.Monad.S2.t               val quaternary :                 ('-> '-> '-> '-> 'e) ->                 ('a, 's) Monads.Std.Monad.S2.t ->                 ('b, 's) Monads.Std.Monad.S2.t ->                 ('c, 's) Monads.Std.Monad.S2.t ->                 ('d, 's) Monads.Std.Monad.S2.t ->                 ('e, 's) Monads.Std.Monad.S2.t               val quinary :                 ('-> '-> '-> '-> '-> 'f) ->                 ('a, 's) Monads.Std.Monad.S2.t ->                 ('b, 's) Monads.Std.Monad.S2.t ->                 ('c, 's) Monads.Std.Monad.S2.t ->                 ('d, 's) Monads.Std.Monad.S2.t ->                 ('e, 's) Monads.Std.Monad.S2.t ->                 ('f, 's) Monads.Std.Monad.S2.t             end           module Exn :             sig               val expect :                 ?finally:(unit -> (unit, 's) Monads.Std.Monad.S2.t) ->                 f:(unit -> ('a, 's) Monads.Std.Monad.S2.t) ->                 catch:(exn -> ('a, 's) Monads.Std.Monad.S2.t) ->                 ('a, 's) Monads.Std.Monad.S2.t             end           module Collection :             sig               module type S =                 sig                   type 'a t                   val all : ('a, 'e) t t -> ('a t, 'e) t                   val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t                   val sequence :                     (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t                   val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t                   val iter :                     'a t ->                     f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t                   val fold :                     'a t ->                     init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                   val fold_left :                     'a t ->                     init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                   val fold_right :                     'a t ->                     f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                   val reduce :                     'a t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                   val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                   val for_all :                     'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                   val count :                     'a t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                   val map_reduce :                     (module Monoid.S with type t = 'a) ->                     'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t                   val find :                     'a t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                   val find_map :                     'a t -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t                   val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t                   val filter_map :                     'a t -> f:('-> ('b option, 'e) t) -> ('b t, 'e) t                 end               module Eager :                 functor (T : Collection.Eager->                   sig                     val all : ('a, 'e) t T.t -> ('T.t, 'e) t                     val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t                     val sequence :                       (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t                     val map :                       'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t                     val iter :                       'T.t ->                       f:('-> (Monoid.Unit.t, 'e) t) ->                       (Monoid.Unit.t, 'e) t                     val fold :                       'T.t ->                       init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                     val fold_left :                       'T.t ->                       init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                     val fold_right :                       'T.t ->                       f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                     val reduce :                       'T.t ->                       f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                     val exists :                       'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                     val for_all :                       'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                     val count :                       'T.t ->                       f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t                     val find :                       'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                     val find_map :                       'T.t ->                       f:('-> ('b option, 'e) t) -> ('b option, 'e) t                     val filter :                       'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t                     val filter_map :                       'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t                   end               module Delay :                 functor (T : Collection.Delay->                   sig                     val all : ('a, 'e) t T.t -> ('T.t, 'e) t                     val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t                     val sequence :                       (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t                     val map :                       'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t                     val iter :                       'T.t ->                       f:('-> (Monoid.Unit.t, 'e) t) ->                       (Monoid.Unit.t, 'e) t                     val fold :                       'T.t ->                       init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                     val fold_left :                       'T.t ->                       init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                     val fold_right :                       'T.t ->                       f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                     val reduce :                       'T.t ->                       f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                     val exists :                       'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                     val for_all :                       'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                     val count :                       'T.t ->                       f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t                     val find :                       'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                     val find_map :                       'T.t ->                       f:('-> ('b option, 'e) t) -> ('b option, 'e) t                     val filter :                       'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t                     val filter_map :                       'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t                   end             end           module List :             sig               val all : ('a, 'e) t list -> ('a list, 'e) t               val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t               val sequence :                 (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t               val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t               val iter :                 'a list ->                 f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t               val fold :                 'a list ->                 init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t               val fold_left :                 'a list ->                 init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t               val fold_right :                 'a list ->                 f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t               val reduce :                 'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t               val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t               val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t               val count :                 'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t               val map_reduce :                 (module Monoid.S with type t = 'a) ->                 'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t               val find :                 'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t               val find_map :                 'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t               val filter :                 'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t               val filter_map :                 'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t             end           module Seq :             sig               val all :                 ('a, 'e) t Core_kernel.Std.Sequence.t ->                 ('Core_kernel.Std.Sequence.t, 'e) t               val all_ignore :                 ('a, 'e) t Core_kernel.Std.Sequence.t ->                 (Monoid.Unit.t, 'e) t               val sequence :                 (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->                 (Monoid.Unit.t, 'e) t               val map :                 'Core_kernel.Std.Sequence.t ->                 f:('-> ('b, 'e) t) -> ('Core_kernel.Std.Sequence.t, 'e) t               val iter :                 'Core_kernel.Std.Sequence.t ->                 f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t               val fold :                 'Core_kernel.Std.Sequence.t ->                 init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t               val fold_left :                 'Core_kernel.Std.Sequence.t ->                 init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t               val fold_right :                 'Core_kernel.Std.Sequence.t ->                 f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t               val reduce :                 'Core_kernel.Std.Sequence.t ->                 f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t               val exists :                 'Core_kernel.Std.Sequence.t ->                 f:('-> (bool, 'e) t) -> (bool, 'e) t               val for_all :                 'Core_kernel.Std.Sequence.t ->                 f:('-> (bool, 'e) t) -> (bool, 'e) t               val count :                 'Core_kernel.Std.Sequence.t ->                 f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t               val map_reduce :                 (module Monoid.S with type t = 'a) ->                 'Core_kernel.Std.Sequence.t ->                 f:('-> ('a, 'e) t) -> ('a, 'e) t               val find :                 'Core_kernel.Std.Sequence.t ->                 f:('-> (bool, 'e) t) -> ('a option, 'e) t               val find_map :                 'Core_kernel.Std.Sequence.t ->                 f:('-> ('b option, 'e) t) -> ('b option, 'e) t               val filter :                 'Core_kernel.Std.Sequence.t ->                 f:('-> (bool, 'e) t) ->                 ('Core_kernel.Std.Sequence.t, 'e) t               val filter_map :                 'Core_kernel.Std.Sequence.t ->                 f:('-> ('b option, 'e) t) ->                 ('Core_kernel.Std.Sequence.t, 'e) t             end           val ( >=> ) :             ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t           val ( !! ) : '-> ('a, 'e) t           val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t           val ( !$$ ) :             ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t           val ( !$$$ ) :             ('-> '-> '-> 'd) ->             ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t           val ( !$$$$ ) :             ('-> '-> '-> '-> 'e) ->             ('a, 's) t ->             ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t           val ( !$$$$$ ) :             ('-> '-> '-> '-> '-> 'f) ->             ('a, 's) t ->             ('b, 's) t ->             ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t           val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t           val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t           module Let_syntax :             sig               module Let_syntax :                 sig                   val return : '-> ('a, 'e) t                   val bind : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t                   val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t                   val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t                   module Open_on_rhs : sig val return : '-> ('a, 'e) t end                   module Open_in_body : sig val return : '-> ('a, 'e) t end                 end             end           module Monad_infix :             sig               val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t               val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t             end           val bind : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t           val return : '-> ('a, 'b) t           val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t           val join : (('a, 'e) t, 'e) t -> ('a, 'e) t           val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t           val all : ('a, 'e) t list -> ('a list, 'e) t           val all_ignore :             (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t           module Syntax :             sig               val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t               val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t               val ( >=> ) :                 ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t               val ( !! ) : '-> ('a, 'e) t               val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t               val ( !$$ ) :                 ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t               val ( !$$$ ) :                 ('-> '-> '-> 'd) ->                 ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t               val ( !$$$$ ) :                 ('-> '-> '-> '-> 'e) ->                 ('a, 's) t ->                 ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t               val ( !$$$$$ ) :                 ('-> '-> '-> '-> '-> 'f) ->                 ('a, 's) t ->                 ('b, 's) t ->                 ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t             end         end       module type Core = Core_kernel.Std.Monad.S       module type Core2 = Core_kernel.Std.Monad.S2       module type Minimal =         sig           type 'a t           val return : '-> 'Monads.Std.Monad.Minimal.t           val bind :             'Monads.Std.Monad.Minimal.t ->             ('-> 'Monads.Std.Monad.Minimal.t) ->             'Monads.Std.Monad.Minimal.t         end       module type Minimal2 =         sig           type ('a, 'e) t           val return : '-> ('a, 'e) Monads.Std.Monad.Minimal2.t           val bind :             ('a, 'e) Monads.Std.Monad.Minimal2.t ->             ('-> ('b, 'e) Monads.Std.Monad.Minimal2.t) ->             ('b, 'e) Monads.Std.Monad.Minimal2.t         end       module Make :         functor (M : Basic->           sig             val void : 'M.t -> Monoid.Unit.t M.t             val sequence : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t             val forever : 'M.t -> 'M.t             module Fn :               sig                 val id : '-> 'M.t                 val ignore : 'M.t -> Monoid.Unit.t M.t                 val nothing : Monoid.Unit.t -> Monoid.Unit.t M.t                 val non : ('-> bool M.t) -> '-> bool M.t                 val apply_n_times :                   n:Monoid.Int.t -> ('-> 'M.t) -> '-> 'M.t                 val compose :                   ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t               end             module Pair :               sig                 val fst : ('a * 'b) M.t -> 'M.t                 val snd : ('a * 'b) M.t -> 'M.t               end             module Triple :               sig                 val fst : ('a * 'b * 'c) M.t -> 'M.t                 val snd : ('a * 'b * 'c) M.t -> 'M.t                 val trd : ('a * 'b * 'c) M.t -> 'M.t               end             module Lift :               sig                 val nullary : '-> 'M.t                 val unary : ('-> 'b) -> 'M.t -> 'M.t                 val binary : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t                 val ternary :                   ('-> '-> '-> 'd) ->                   'M.t -> 'M.t -> 'M.t -> 'M.t                 val quaternary :                   ('-> '-> '-> '-> 'e) ->                   'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t                 val quinary :                   ('-> '-> '-> '-> '-> 'f) ->                   'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t               end             module Exn :               sig                 val expect :                   ?finally:(Monoid.Unit.t -> Monoid.Unit.t M.t) ->                   f:(Monoid.Unit.t -> 'M.t) ->                   catch:(exn -> 'M.t) -> 'M.t               end             module Collection :               sig                 module type S =                   sig                     type 'a t                     val all : 'M.t t -> 'a t M.t                     val all_ignore : 'M.t t -> Monoid.Unit.t M.t                     val sequence : Monoid.Unit.t M.t t -> Monoid.Unit.t M.t                     val map : 'a t -> f:('-> 'M.t) -> 'b t M.t                     val iter :                       'a t ->                       f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t                     val fold :                       'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                     val fold_left :                       'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                     val fold_right :                       'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t                     val reduce :                       'a t -> f:('-> '-> 'M.t) -> 'a option M.t                     val exists : 'a t -> f:('-> bool M.t) -> bool M.t                     val for_all : 'a t -> f:('-> bool M.t) -> bool M.t                     val count :                       'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'b t -> f:('-> 'M.t) -> 'M.t                     val find : 'a t -> f:('-> bool M.t) -> 'a option M.t                     val find_map :                       'a t -> f:('-> 'b option M.t) -> 'b option M.t                     val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t                     val filter_map :                       'a t -> f:('-> 'b option M.t) -> 'b t M.t                   end                 module Eager :                   functor (T : Collection.Eager->                     sig                       val all : 'M.t T.t -> 'T.t M.t                       val all_ignore : 'M.t T.t -> Monoid.Unit.t M.t                       val sequence :                         Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t                       val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t                       val iter :                         'T.t ->                         f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t                       val fold :                         'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                       val fold_left :                         'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                       val fold_right :                         'T.t -> f:('-> '-> 'M.t) -> init:'-> 'M.t                       val reduce :                         'T.t -> f:('-> '-> 'M.t) -> 'a option M.t                       val exists : 'T.t -> f:('-> bool M.t) -> bool M.t                       val for_all : 'T.t -> f:('-> bool M.t) -> bool M.t                       val count :                         'T.t -> f:('-> bool M.t) -> Monoid.Int.t M.t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> 'M.t) -> 'M.t                       val find :                         'T.t -> f:('-> bool M.t) -> 'a option M.t                       val find_map :                         'T.t -> f:('-> 'b option M.t) -> 'b option M.t                       val filter : 'T.t -> f:('-> bool M.t) -> 'T.t M.t                       val filter_map :                         'T.t -> f:('-> 'b option M.t) -> 'T.t M.t                     end                 module Delay :                   functor (T : Collection.Delay->                     sig                       val all : 'M.t T.t -> 'T.t M.t                       val all_ignore : 'M.t T.t -> Monoid.Unit.t M.t                       val sequence :                         Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t                       val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t                       val iter :                         'T.t ->                         f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t                       val fold :                         'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                       val fold_left :                         'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                       val fold_right :                         'T.t -> f:('-> '-> 'M.t) -> init:'-> 'M.t                       val reduce :                         'T.t -> f:('-> '-> 'M.t) -> 'a option M.t                       val exists : 'T.t -> f:('-> bool M.t) -> bool M.t                       val for_all : 'T.t -> f:('-> bool M.t) -> bool M.t                       val count :                         'T.t -> f:('-> bool M.t) -> Monoid.Int.t M.t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> 'M.t) -> 'M.t                       val find :                         'T.t -> f:('-> bool M.t) -> 'a option M.t                       val find_map :                         'T.t -> f:('-> 'b option M.t) -> 'b option M.t                       val filter : 'T.t -> f:('-> bool M.t) -> 'T.t M.t                       val filter_map :                         'T.t -> f:('-> 'b option M.t) -> 'T.t M.t                     end               end             module List :               sig                 val all : 'M.t list -> 'a list M.t                 val all_ignore : 'M.t list -> Monoid.Unit.t M.t                 val sequence : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t                 val map : 'a list -> f:('-> 'M.t) -> 'b list M.t                 val iter :                   'a list -> f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t                 val fold :                   'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t                 val fold_left :                   'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t                 val fold_right :                   'a list -> f:('-> '-> 'M.t) -> init:'-> 'M.t                 val reduce :                   'a list -> f:('-> '-> 'M.t) -> 'a option M.t                 val exists : 'a list -> f:('-> bool M.t) -> bool M.t                 val for_all : 'a list -> f:('-> bool M.t) -> bool M.t                 val count : 'a list -> f:('-> bool M.t) -> Monoid.Int.t M.t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'b list -> f:('-> 'M.t) -> 'M.t                 val find : 'a list -> f:('-> bool M.t) -> 'a option M.t                 val find_map :                   'a list -> f:('-> 'b option M.t) -> 'b option M.t                 val filter : 'a list -> f:('-> bool M.t) -> 'a list M.t                 val filter_map :                   'a list -> f:('-> 'b option M.t) -> 'b list M.t               end             module Seq :               sig                 val all :                   'M.t Core_kernel.Std.Sequence.t ->                   'Core_kernel.Std.Sequence.t M.t                 val all_ignore :                   'M.t Core_kernel.Std.Sequence.t -> Monoid.Unit.t M.t                 val sequence :                   Monoid.Unit.t M.t Core_kernel.Std.Sequence.t ->                   Monoid.Unit.t M.t                 val map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'M.t) -> 'Core_kernel.Std.Sequence.t M.t                 val iter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t                 val fold :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> 'M.t) -> 'M.t                 val fold_left :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> 'M.t) -> 'M.t                 val fold_right :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> 'M.t) -> init:'-> 'M.t                 val reduce :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> 'M.t) -> 'a option M.t                 val exists :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool M.t) -> bool M.t                 val for_all :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool M.t) -> bool M.t                 val count :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool M.t) -> Monoid.Int.t M.t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'Core_kernel.Std.Sequence.t -> f:('-> 'M.t) -> 'M.t                 val find :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool M.t) -> 'a option M.t                 val find_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b option M.t) -> 'b option M.t                 val filter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool M.t) -> 'Core_kernel.Std.Sequence.t M.t                 val filter_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b option M.t) ->                   'Core_kernel.Std.Sequence.t M.t               end             val ( >=> ) : ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t             val ( !! ) : '-> 'M.t             val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t             val ( !$$ ) : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t             val ( !$$$ ) :               ('-> '-> '-> 'd) -> 'M.t -> 'M.t -> 'M.t -> 'M.t             val ( !$$$$ ) :               ('-> '-> '-> '-> 'e) ->               'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t             val ( !$$$$$ ) :               ('-> '-> '-> '-> '-> 'f) ->               'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t             val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t             val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t             module Monad_infix :               sig                 val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t                 val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t               end             val bind : 'M.t -> ('-> 'M.t) -> 'M.t             val return : '-> 'M.t             val map : 'M.t -> f:('-> 'b) -> 'M.t             val join : 'M.t M.t -> 'M.t             val ignore_m : 'M.t -> Monoid.Unit.t M.t             val all : 'M.t list -> 'a list M.t             val all_ignore : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t             module Let_syntax :               sig                 module Let_syntax :                   sig                     val return : '-> 'M.t                     val bind : 'M.t -> ('-> 'M.t) -> 'M.t                     val map : 'M.t -> f:('-> 'b) -> 'M.t                     val both : 'M.t -> 'M.t -> ('a * 'b) M.t                     module Open_on_rhs : sig val return : '-> 'M.t end                     module Open_in_body : sig val return : '-> 'M.t end                   end               end             module Syntax :               sig                 val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t                 val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t                 val ( >=> ) :                   ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t                 val ( !! ) : '-> 'M.t                 val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t                 val ( !$$ ) : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t                 val ( !$$$ ) :                   ('-> '-> '-> 'd) ->                   'M.t -> 'M.t -> 'M.t -> 'M.t                 val ( !$$$$ ) :                   ('-> '-> '-> '-> 'e) ->                   'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t                 val ( !$$$$$ ) :                   ('-> '-> '-> '-> '-> 'f) ->                   'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t               end           end       module Make2 :         functor (M : Basic2->           sig             val void : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t             val sequence :               (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t             val forever : ('a, 'e) M.t -> ('b, 'e) M.t             module Fn :               sig                 val id : '-> ('a, 'e) M.t                 val ignore : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t                 val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) M.t                 val non : ('-> (bool, 'e) M.t) -> '-> (bool, 'e) M.t                 val apply_n_times :                   n:Monoid.Int.t ->                   ('-> ('a, 'e) M.t) -> '-> ('a, 'e) M.t                 val compose :                   ('-> ('c, 'e) M.t) ->                   ('-> ('b, 'e) M.t) -> '-> ('c, 'e) M.t               end             module Pair :               sig                 val fst : ('a * 'b, 'e) M.t -> ('a, 'e) M.t                 val snd : ('a * 'b, 'e) M.t -> ('b, 'e) M.t               end             module Triple :               sig                 val fst : ('a * 'b * 'c, 'e) M.t -> ('a, 'e) M.t                 val snd : ('a * 'b * 'c, 'e) M.t -> ('b, 'e) M.t                 val trd : ('a * 'b * 'c, 'e) M.t -> ('c, 'e) M.t               end             module Lift :               sig                 val nullary : '-> ('a, 'e) M.t                 val unary : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t                 val binary :                   ('-> '-> 'c) ->                   ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t                 val ternary :                   ('-> '-> '-> 'd) ->                   ('a, 'e) M.t ->                   ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t                 val quaternary :                   ('-> '-> '-> '-> 'e) ->                   ('a, 's) M.t ->                   ('b, 's) M.t ->                   ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t                 val quinary :                   ('-> '-> '-> '-> '-> 'f) ->                   ('a, 's) M.t ->                   ('b, 's) M.t ->                   ('c, 's) M.t ->                   ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t               end             module Exn :               sig                 val expect :                   ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) M.t) ->                   f:(Monoid.Unit.t -> ('a, 's) M.t) ->                   catch:(exn -> ('a, 's) M.t) -> ('a, 's) M.t               end             module Collection :               sig                 module type S =                   sig                     type 'a t                     val all : ('a, 'e) M.t t -> ('a t, 'e) M.t                     val all_ignore :                       ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t                     val sequence :                       (Monoid.Unit.t, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t                     val map :                       'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t                     val iter :                       'a t ->                       f:('-> (Monoid.Unit.t, 'e) M.t) ->                       (Monoid.Unit.t, 'e) M.t                     val fold :                       'a t ->                       init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                     val fold_left :                       'a t ->                       init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                     val fold_right :                       'a t ->                       f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t                     val reduce :                       'a t ->                       f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t                     val exists :                       'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                     val for_all :                       'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                     val count :                       'a t ->                       f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t                     val find :                       'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t                     val find_map :                       'a t ->                       f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t                     val filter :                       'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t                     val filter_map :                       'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t                   end                 module Eager :                   functor (T : Collection.Eager->                     sig                       val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t                       val all_ignore :                         ('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t                       val sequence :                         (Monoid.Unit.t, 'e) M.t T.t ->                         (Monoid.Unit.t, 'e) M.t                       val map :                         'T.t -> f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t                       val iter :                         'T.t ->                         f:('-> (Monoid.Unit.t, 'e) M.t) ->                         (Monoid.Unit.t, 'e) M.t                       val fold :                         'T.t ->                         init:'->                         f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                       val fold_left :                         'T.t ->                         init:'->                         f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                       val fold_right :                         'T.t ->                         f:('-> '-> ('b, 'e) M.t) ->                         init:'-> ('b, 'e) M.t                       val reduce :                         'T.t ->                         f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t                       val exists :                         'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                       val for_all :                         'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                       val count :                         'T.t ->                         f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t                       val find :                         'T.t ->                         f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t                       val find_map :                         'T.t ->                         f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t                       val filter :                         'T.t ->                         f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t                       val filter_map :                         'T.t ->                         f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t                     end                 module Delay :                   functor (T : Collection.Delay->                     sig                       val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t                       val all_ignore :                         ('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t                       val sequence :                         (Monoid.Unit.t, 'e) M.t T.t ->                         (Monoid.Unit.t, 'e) M.t                       val map :                         'T.t -> f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t                       val iter :                         'T.t ->                         f:('-> (Monoid.Unit.t, 'e) M.t) ->                         (Monoid.Unit.t, 'e) M.t                       val fold :                         'T.t ->                         init:'->                         f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                       val fold_left :                         'T.t ->                         init:'->                         f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                       val fold_right :                         'T.t ->                         f:('-> '-> ('b, 'e) M.t) ->                         init:'-> ('b, 'e) M.t                       val reduce :                         'T.t ->                         f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t                       val exists :                         'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                       val for_all :                         'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                       val count :                         'T.t ->                         f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t                       val find :                         'T.t ->                         f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t                       val find_map :                         'T.t ->                         f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t                       val filter :                         'T.t ->                         f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t                       val filter_map :                         'T.t ->                         f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t                     end               end             module List :               sig                 val all : ('a, 'e) M.t list -> ('a list, 'e) M.t                 val all_ignore : ('a, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t                 val sequence :                   (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t                 val map :                   'a list -> f:('-> ('b, 'e) M.t) -> ('b list, 'e) M.t                 val iter :                   'a list ->                   f:('-> (Monoid.Unit.t, 'e) M.t) ->                   (Monoid.Unit.t, 'e) M.t                 val fold :                   'a list ->                   init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                 val fold_left :                   'a list ->                   init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                 val fold_right :                   'a list ->                   f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t                 val reduce :                   'a list ->                   f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t                 val exists :                   'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                 val for_all :                   'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                 val count :                   'a list ->                   f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'b list -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t                 val find :                   'a list -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t                 val find_map :                   'a list ->                   f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t                 val filter :                   'a list -> f:('-> (bool, 'e) M.t) -> ('a list, 'e) M.t                 val filter_map :                   'a list ->                   f:('-> ('b option, 'e) M.t) -> ('b list, 'e) M.t               end             module Seq :               sig                 val all :                   ('a, 'e) M.t Core_kernel.Std.Sequence.t ->                   ('Core_kernel.Std.Sequence.t, 'e) M.t                 val all_ignore :                   ('a, 'e) M.t Core_kernel.Std.Sequence.t ->                   (Monoid.Unit.t, 'e) M.t                 val sequence :                   (Monoid.Unit.t, 'e) M.t Core_kernel.Std.Sequence.t ->                   (Monoid.Unit.t, 'e) M.t                 val map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b, 'e) M.t) ->                   ('Core_kernel.Std.Sequence.t, 'e) M.t                 val iter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (Monoid.Unit.t, 'e) M.t) ->                   (Monoid.Unit.t, 'e) M.t                 val fold :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                 val fold_left :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                 val fold_right :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t                 val reduce :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t                 val exists :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                 val for_all :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                 val count :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t                 val find :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t                 val find_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t                 val filter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) M.t) ->                   ('Core_kernel.Std.Sequence.t, 'e) M.t                 val filter_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b option, 'e) M.t) ->                   ('Core_kernel.Std.Sequence.t, 'e) M.t               end             val ( >=> ) :               ('-> ('b, 'e) M.t) ->               ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t             val ( !! ) : '-> ('a, 'e) M.t             val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t             val ( !$$ ) :               ('-> '-> 'c) ->               ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t             val ( !$$$ ) :               ('-> '-> '-> 'd) ->               ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t             val ( !$$$$ ) :               ('-> '-> '-> '-> 'e) ->               ('a, 's) M.t ->               ('b, 's) M.t -> ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t             val ( !$$$$$ ) :               ('-> '-> '-> '-> '-> 'f) ->               ('a, 's) M.t ->               ('b, 's) M.t ->               ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t             val ( >>= ) :               ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t             val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t             module Let_syntax :               sig                 module Let_syntax :                   sig                     val return : '-> ('a, 'e) M.t                     val bind :                       ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t                     val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t                     val both :                       ('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t                     module Open_on_rhs :                       sig val return : '-> ('a, 'e) M.t end                     module Open_in_body :                       sig val return : '-> ('a, 'e) M.t end                   end               end             module Monad_infix :               sig                 val ( >>= ) :                   ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t                 val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t               end             val bind : ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t             val return : '-> ('a, 'b) M.t             val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t             val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t             val ignore_m : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t             val all : ('a, 'e) M.t list -> ('a list, 'e) M.t             val all_ignore :               (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t             module Syntax :               sig                 val ( >>= ) :                   ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t                 val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t                 val ( >=> ) :                   ('-> ('b, 'e) M.t) ->                   ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t                 val ( !! ) : '-> ('a, 'e) M.t                 val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t                 val ( !$$ ) :                   ('-> '-> 'c) ->                   ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t                 val ( !$$$ ) :                   ('-> '-> '-> 'd) ->                   ('a, 'e) M.t ->                   ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t                 val ( !$$$$ ) :                   ('-> '-> '-> '-> 'e) ->                   ('a, 's) M.t ->                   ('b, 's) M.t ->                   ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t                 val ( !$$$$$ ) :                   ('-> '-> '-> '-> '-> 'f) ->                   ('a, 's) M.t ->                   ('b, 's) M.t ->                   ('c, 's) M.t ->                   ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t               end           end       module Core :         functor (M : Core->           sig             type 'a t = 'M.t             val void : 'a t -> Monoid.Unit.t t             val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t             val forever : 'a t -> 'b t             module Fn :               sig                 val id : '-> 'a t                 val ignore : 'a t -> Monoid.Unit.t t                 val nothing : Monoid.Unit.t -> Monoid.Unit.t t                 val non : ('-> bool t) -> '-> bool t                 val apply_n_times :                   n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t                 val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t               end             module Pair :               sig                 val fst : ('a * 'b) t -> 'a t                 val snd : ('a * 'b) t -> 'b t               end             module Triple :               sig                 val fst : ('a * 'b * 'c) t -> 'a t                 val snd : ('a * 'b * 'c) t -> 'b t                 val trd : ('a * 'b * 'c) t -> 'c t               end             module Lift :               sig                 val nullary : '-> 'a t                 val unary : ('-> 'b) -> 'a t -> 'b t                 val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t                 val ternary :                   ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t                 val quaternary :                   ('-> '-> '-> '-> 'e) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t                 val quinary :                   ('-> '-> '-> '-> '-> 'f) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t               end             module Exn :               sig                 val expect :                   ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->                   f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t               end             module Collection :               sig                 module type S =                   sig                     type 'a t                     val all : 'M.t t -> 'a t M.t                     val all_ignore : 'M.t t -> Monoid.Unit.t M.t                     val sequence : Monoid.Unit.t M.t t -> Monoid.Unit.t M.t                     val map : 'a t -> f:('-> 'M.t) -> 'b t M.t                     val iter :                       'a t ->                       f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t                     val fold :                       'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                     val fold_left :                       'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                     val fold_right :                       'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t                     val reduce :                       'a t -> f:('-> '-> 'M.t) -> 'a option M.t                     val exists : 'a t -> f:('-> bool M.t) -> bool M.t                     val for_all : 'a t -> f:('-> bool M.t) -> bool M.t                     val count :                       'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'b t -> f:('-> 'M.t) -> 'M.t                     val find : 'a t -> f:('-> bool M.t) -> 'a option M.t                     val find_map :                       'a t -> f:('-> 'b option M.t) -> 'b option M.t                     val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t                     val filter_map :                       'a t -> f:('-> 'b option M.t) -> 'b t M.t                   end                 module Eager :                   functor (T : Collection.Eager->                     sig                       val all : 'a t T.t -> 'T.t t                       val all_ignore : 'a t T.t -> Monoid.Unit.t t                       val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t                       val map : 'T.t -> f:('-> 'b t) -> 'T.t t                       val iter :                         'T.t ->                         f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                       val fold :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_left :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_right :                         'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t                       val reduce :                         'T.t -> f:('-> '-> 'a t) -> 'a option t                       val exists : 'T.t -> f:('-> bool t) -> bool t                       val for_all : 'T.t -> f:('-> bool t) -> bool t                       val count :                         'T.t -> f:('-> bool t) -> Monoid.Int.t t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> 'a t) -> 'a t                       val find : 'T.t -> f:('-> bool t) -> 'a option t                       val find_map :                         'T.t -> f:('-> 'b option t) -> 'b option t                       val filter : 'T.t -> f:('-> bool t) -> 'T.t t                       val filter_map :                         'T.t -> f:('-> 'b option t) -> 'T.t t                     end                 module Delay :                   functor (T : Collection.Delay->                     sig                       val all : 'a t T.t -> 'T.t t                       val all_ignore : 'a t T.t -> Monoid.Unit.t t                       val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t                       val map : 'T.t -> f:('-> 'b t) -> 'T.t t                       val iter :                         'T.t ->                         f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                       val fold :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_left :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_right :                         'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t                       val reduce :                         'T.t -> f:('-> '-> 'a t) -> 'a option t                       val exists : 'T.t -> f:('-> bool t) -> bool t                       val for_all : 'T.t -> f:('-> bool t) -> bool t                       val count :                         'T.t -> f:('-> bool t) -> Monoid.Int.t t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> 'a t) -> 'a t                       val find : 'T.t -> f:('-> bool t) -> 'a option t                       val find_map :                         'T.t -> f:('-> 'b option t) -> 'b option t                       val filter : 'T.t -> f:('-> bool t) -> 'T.t t                       val filter_map :                         'T.t -> f:('-> 'b option t) -> 'T.t t                     end               end             module List :               sig                 val all : 'a t list -> 'a list t                 val all_ignore : 'a t list -> Monoid.Unit.t t                 val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t                 val map : 'a list -> f:('-> 'b t) -> 'b list t                 val iter :                   'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                 val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_left :                   'a list -> init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_right :                   'a list -> f:('-> '-> 'b t) -> init:'-> 'b t                 val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t                 val exists : 'a list -> f:('-> bool t) -> bool t                 val for_all : 'a list -> f:('-> bool t) -> bool t                 val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'b list -> f:('-> 'a t) -> 'a t                 val find : 'a list -> f:('-> bool t) -> 'a option t                 val find_map :                   'a list -> f:('-> 'b option t) -> 'b option t                 val filter : 'a list -> f:('-> bool t) -> 'a list t                 val filter_map :                   'a list -> f:('-> 'b option t) -> 'b list t               end             module Seq :               sig                 val all :                   'a t Core_kernel.Std.Sequence.t ->                   'Core_kernel.Std.Sequence.t t                 val all_ignore :                   'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t                 val sequence :                   Monoid.Unit.t t Core_kernel.Std.Sequence.t ->                   Monoid.Unit.t t                 val map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t                 val iter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                 val fold :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_left :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_right :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> 'b t) -> init:'-> 'b t                 val reduce :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> 'a t) -> 'a option t                 val exists :                   'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t                 val for_all :                   'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t                 val count :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool t) -> Monoid.Int.t t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t                 val find :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool t) -> 'a option t                 val find_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b option t) -> 'b option t                 val filter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t                 val filter_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t               end             val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t             val ( !! ) : '-> 'a t             val ( !$ ) : ('-> 'b) -> 'a t -> 'b t             val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t             val ( !$$$ ) :               ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t             val ( !$$$$ ) :               ('-> '-> '-> '-> 'e) ->               'a t -> 'b t -> 'c t -> 'd t -> 'e t             val ( !$$$$$ ) :               ('-> '-> '-> '-> '-> 'f) ->               'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t             val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t             val ( >>| ) : 'a t -> ('-> 'b) -> 'b t             module Monad_infix :               sig                 val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t                 val ( >>| ) : 'a t -> ('-> 'b) -> 'b t               end             val bind : 'a t -> ('-> 'b t) -> 'b t             val return : '-> 'a t             val map : 'a t -> f:('-> 'b) -> 'b t             val join : 'a t t -> 'a t             val ignore_m : 'a t -> Monoid.Unit.t t             val all : 'a t list -> 'a list t             val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t             module Let_syntax :               sig                 module Let_syntax :                   sig                     val return : '-> 'a t                     val bind : 'a t -> ('-> 'b t) -> 'b t                     val map : 'a t -> f:('-> 'b) -> 'b t                     val both : 'a t -> 'b t -> ('a * 'b) t                     module Open_on_rhs : sig val return : '-> 'a t end                     module Open_in_body : sig val return : '-> 'a t end                   end               end             module Syntax :               sig                 val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t                 val ( >>| ) : 'a t -> ('-> 'b) -> 'b t                 val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t                 val ( !! ) : '-> 'a t                 val ( !$ ) : ('-> 'b) -> 'a t -> 'b t                 val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t                 val ( !$$$ ) :                   ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t                 val ( !$$$$ ) :                   ('-> '-> '-> '-> 'e) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t                 val ( !$$$$$ ) :                   ('-> '-> '-> '-> '-> 'f) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t               end           end       module Core2 :         functor (M : Core2->           sig             type ('a, 'e) t = ('a, 'e) M.t             val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t             val sequence :               (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t             val forever : ('a, 'e) t -> ('b, 'e) t             module Fn :               sig                 val id : '-> ('a, 'e) t                 val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t                 val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t                 val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t                 val apply_n_times :                   n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t                 val compose :                   ('-> ('c, 'e) t) ->                   ('-> ('b, 'e) t) -> '-> ('c, 'e) t               end             module Pair :               sig                 val fst : ('a * 'b, 'e) t -> ('a, 'e) t                 val snd : ('a * 'b, 'e) t -> ('b, 'e) t               end             module Triple :               sig                 val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t                 val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t                 val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t               end             module Lift :               sig                 val nullary : '-> ('a, 'e) t                 val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t                 val binary :                   ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t                 val ternary :                   ('-> '-> '-> 'd) ->                   ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t                 val quaternary :                   ('-> '-> '-> '-> 'e) ->                   ('a, 's) t ->                   ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t                 val quinary :                   ('-> '-> '-> '-> '-> 'f) ->                   ('a, 's) t ->                   ('b, 's) t ->                   ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t               end             module Exn :               sig                 val expect :                   ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->                   f:(Monoid.Unit.t -> ('a, 's) t) ->                   catch:(exn -> ('a, 's) t) -> ('a, 's) t               end             module Collection :               sig                 module type S =                   sig                     type 'a t                     val all : ('a, 'e) M.t t -> ('a t, 'e) M.t                     val all_ignore :                       ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t                     val sequence :                       (Monoid.Unit.t, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t                     val map :                       'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t                     val iter :                       'a t ->                       f:('-> (Monoid.Unit.t, 'e) M.t) ->                       (Monoid.Unit.t, 'e) M.t                     val fold :                       'a t ->                       init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                     val fold_left :                       'a t ->                       init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                     val fold_right :                       'a t ->                       f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t                     val reduce :                       'a t ->                       f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t                     val exists :                       'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                     val for_all :                       'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                     val count :                       'a t ->                       f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t                     val find :                       'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t                     val find_map :                       'a t ->                       f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t                     val filter :                       'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t                     val filter_map :                       'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t                   end                 module Eager :                   functor (T : Collection.Eager->                     sig                       val all : ('a, 'e) t T.t -> ('T.t, 'e) t                       val all_ignore :                         ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val sequence :                         (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val map :                         'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t                       val iter :                         'T.t ->                         f:('-> (Monoid.Unit.t, 'e) t) ->                         (Monoid.Unit.t, 'e) t                       val fold :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_left :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_right :                         'T.t ->                         f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                       val reduce :                         'T.t ->                         f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                       val exists :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val for_all :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val count :                         'T.t ->                         f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t                       val find :                         'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                       val find_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('b option, 'e) t                       val filter :                         'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t                       val filter_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('T.t, 'e) t                     end                 module Delay :                   functor (T : Collection.Delay->                     sig                       val all : ('a, 'e) t T.t -> ('T.t, 'e) t                       val all_ignore :                         ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val sequence :                         (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val map :                         'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t                       val iter :                         'T.t ->                         f:('-> (Monoid.Unit.t, 'e) t) ->                         (Monoid.Unit.t, 'e) t                       val fold :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_left :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_right :                         'T.t ->                         f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                       val reduce :                         'T.t ->                         f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                       val exists :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val for_all :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val count :                         'T.t ->                         f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t                       val find :                         'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                       val find_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('b option, 'e) t                       val filter :                         'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t                       val filter_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('T.t, 'e) t                     end               end             module List :               sig                 val all : ('a, 'e) t list -> ('a list, 'e) t                 val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t                 val sequence :                   (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t                 val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t                 val iter :                   'a list ->                   f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t                 val fold :                   'a list ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_left :                   'a list ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_right :                   'a list ->                   f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                 val reduce :                   'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                 val exists :                   'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t                 val for_all :                   'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t                 val count :                   'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t                 val find :                   'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                 val find_map :                   'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t                 val filter :                   'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t                 val filter_map :                   'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t               end             module Seq :               sig                 val all :                   ('a, 'e) t Core_kernel.Std.Sequence.t ->                   ('Core_kernel.Std.Sequence.t, 'e) t                 val all_ignore :                   ('a, 'e) t Core_kernel.Std.Sequence.t ->                   (Monoid.Unit.t, 'e) t                 val sequence :                   (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->                   (Monoid.Unit.t, 'e) t                 val map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b, 'e) t) ->                   ('Core_kernel.Std.Sequence.t, 'e) t                 val iter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t                 val fold :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_left :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_right :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                 val reduce :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                 val exists :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> (bool, 'e) t                 val for_all :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> (bool, 'e) t                 val count :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('a, 'e) t) -> ('a, 'e) t                 val find :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> ('a option, 'e) t                 val find_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b option, 'e) t) -> ('b option, 'e) t                 val filter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) ->                   ('Core_kernel.Std.Sequence.t, 'e) t                 val filter_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b option, 'e) t) ->                   ('Core_kernel.Std.Sequence.t, 'e) t               end             val ( >=> ) :               ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t             val ( !! ) : '-> ('a, 'e) t             val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t             val ( !$$ ) :               ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t             val ( !$$$ ) :               ('-> '-> '-> 'd) ->               ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t             val ( !$$$$ ) :               ('-> '-> '-> '-> 'e) ->               ('a, 's) t ->               ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t             val ( !$$$$$ ) :               ('-> '-> '-> '-> '-> 'f) ->               ('a, 's) t ->               ('b, 's) t ->               ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t             val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t             val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t             module Let_syntax :               sig                 module Let_syntax :                   sig                     val return : '-> ('a, 'e) t                     val bind : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t                     val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t                     val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t                     module Open_on_rhs :                       sig val return : '-> ('a, 'e) t end                     module Open_in_body :                       sig val return : '-> ('a, 'e) t end                   end               end             module Monad_infix :               sig                 val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t                 val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t               end             val bind : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t             val return : '-> ('a, 'b) t             val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t             val join : (('a, 'e) t, 'e) t -> ('a, 'e) t             val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t             val all : ('a, 'e) t list -> ('a list, 'e) t             val all_ignore :               (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t             module Syntax :               sig                 val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t                 val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t                 val ( >=> ) :                   ('-> ('b, 'e) t) ->                   ('-> ('c, 'e) t) -> '-> ('c, 'e) t                 val ( !! ) : '-> ('a, 'e) t                 val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t                 val ( !$$ ) :                   ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t                 val ( !$$$ ) :                   ('-> '-> '-> 'd) ->                   ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t                 val ( !$$$$ ) :                   ('-> '-> '-> '-> 'e) ->                   ('a, 's) t ->                   ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t                 val ( !$$$$$ ) :                   ('-> '-> '-> '-> '-> 'f) ->                   ('a, 's) t ->                   ('b, 's) t ->                   ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t               end           end       module Minimal :         functor (M : Minimal->           sig             type 'a t = 'M.t             val void : 'a t -> Monoid.Unit.t t             val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t             val forever : 'a t -> 'b t             module Fn :               sig                 val id : '-> 'a t                 val ignore : 'a t -> Monoid.Unit.t t                 val nothing : Monoid.Unit.t -> Monoid.Unit.t t                 val non : ('-> bool t) -> '-> bool t                 val apply_n_times :                   n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t                 val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t               end             module Pair :               sig                 val fst : ('a * 'b) t -> 'a t                 val snd : ('a * 'b) t -> 'b t               end             module Triple :               sig                 val fst : ('a * 'b * 'c) t -> 'a t                 val snd : ('a * 'b * 'c) t -> 'b t                 val trd : ('a * 'b * 'c) t -> 'c t               end             module Lift :               sig                 val nullary : '-> 'a t                 val unary : ('-> 'b) -> 'a t -> 'b t                 val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t                 val ternary :                   ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t                 val quaternary :                   ('-> '-> '-> '-> 'e) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t                 val quinary :                   ('-> '-> '-> '-> '-> 'f) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t               end             module Exn :               sig                 val expect :                   ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->                   f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t               end             module Collection :               sig                 module type S =                   sig                     type 'a t                     val all : 'M.t t -> 'a t M.t                     val all_ignore : 'M.t t -> Monoid.Unit.t M.t                     val sequence : Monoid.Unit.t M.t t -> Monoid.Unit.t M.t                     val map : 'a t -> f:('-> 'M.t) -> 'b t M.t                     val iter :                       'a t ->                       f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t                     val fold :                       'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                     val fold_left :                       'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t                     val fold_right :                       'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t                     val reduce :                       'a t -> f:('-> '-> 'M.t) -> 'a option M.t                     val exists : 'a t -> f:('-> bool M.t) -> bool M.t                     val for_all : 'a t -> f:('-> bool M.t) -> bool M.t                     val count :                       'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'b t -> f:('-> 'M.t) -> 'M.t                     val find : 'a t -> f:('-> bool M.t) -> 'a option M.t                     val find_map :                       'a t -> f:('-> 'b option M.t) -> 'b option M.t                     val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t                     val filter_map :                       'a t -> f:('-> 'b option M.t) -> 'b t M.t                   end                 module Eager :                   functor (T : Collection.Eager->                     sig                       val all : 'a t T.t -> 'T.t t                       val all_ignore : 'a t T.t -> Monoid.Unit.t t                       val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t                       val map : 'T.t -> f:('-> 'b t) -> 'T.t t                       val iter :                         'T.t ->                         f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                       val fold :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_left :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_right :                         'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t                       val reduce :                         'T.t -> f:('-> '-> 'a t) -> 'a option t                       val exists : 'T.t -> f:('-> bool t) -> bool t                       val for_all : 'T.t -> f:('-> bool t) -> bool t                       val count :                         'T.t -> f:('-> bool t) -> Monoid.Int.t t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> 'a t) -> 'a t                       val find : 'T.t -> f:('-> bool t) -> 'a option t                       val find_map :                         'T.t -> f:('-> 'b option t) -> 'b option t                       val filter : 'T.t -> f:('-> bool t) -> 'T.t t                       val filter_map :                         'T.t -> f:('-> 'b option t) -> 'T.t t                     end                 module Delay :                   functor (T : Collection.Delay->                     sig                       val all : 'a t T.t -> 'T.t t                       val all_ignore : 'a t T.t -> Monoid.Unit.t t                       val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t                       val map : 'T.t -> f:('-> 'b t) -> 'T.t t                       val iter :                         'T.t ->                         f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                       val fold :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_left :                         'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t                       val fold_right :                         'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t                       val reduce :                         'T.t -> f:('-> '-> 'a t) -> 'a option t                       val exists : 'T.t -> f:('-> bool t) -> bool t                       val for_all : 'T.t -> f:('-> bool t) -> bool t                       val count :                         'T.t -> f:('-> bool t) -> Monoid.Int.t t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> 'a t) -> 'a t                       val find : 'T.t -> f:('-> bool t) -> 'a option t                       val find_map :                         'T.t -> f:('-> 'b option t) -> 'b option t                       val filter : 'T.t -> f:('-> bool t) -> 'T.t t                       val filter_map :                         'T.t -> f:('-> 'b option t) -> 'T.t t                     end               end             module List :               sig                 val all : 'a t list -> 'a list t                 val all_ignore : 'a t list -> Monoid.Unit.t t                 val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t                 val map : 'a list -> f:('-> 'b t) -> 'b list t                 val iter :                   'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                 val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_left :                   'a list -> init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_right :                   'a list -> f:('-> '-> 'b t) -> init:'-> 'b t                 val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t                 val exists : 'a list -> f:('-> bool t) -> bool t                 val for_all : 'a list -> f:('-> bool t) -> bool t                 val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'b list -> f:('-> 'a t) -> 'a t                 val find : 'a list -> f:('-> bool t) -> 'a option t                 val find_map :                   'a list -> f:('-> 'b option t) -> 'b option t                 val filter : 'a list -> f:('-> bool t) -> 'a list t                 val filter_map :                   'a list -> f:('-> 'b option t) -> 'b list t               end             module Seq :               sig                 val all :                   'a t Core_kernel.Std.Sequence.t ->                   'Core_kernel.Std.Sequence.t t                 val all_ignore :                   'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t                 val sequence :                   Monoid.Unit.t t Core_kernel.Std.Sequence.t ->                   Monoid.Unit.t t                 val map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t                 val iter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t                 val fold :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_left :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> 'b t) -> 'b t                 val fold_right :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> 'b t) -> init:'-> 'b t                 val reduce :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> 'a t) -> 'a option t                 val exists :                   'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t                 val for_all :                   'Core_kernel.Std.Sequence.t -> f:('-> bool t) -> bool t                 val count :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool t) -> Monoid.Int.t t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t                 val find :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool t) -> 'a option t                 val find_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b option t) -> 'b option t                 val filter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t                 val filter_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t               end             val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t             val ( !! ) : '-> 'a t             val ( !$ ) : ('-> 'b) -> 'a t -> 'b t             val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t             val ( !$$$ ) :               ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t             val ( !$$$$ ) :               ('-> '-> '-> '-> 'e) ->               'a t -> 'b t -> 'c t -> 'd t -> 'e t             val ( !$$$$$ ) :               ('-> '-> '-> '-> '-> 'f) ->               'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t             val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t             val ( >>| ) : 'a t -> ('-> 'b) -> 'b t             module Monad_infix :               sig                 val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t                 val ( >>| ) : 'a t -> ('-> 'b) -> 'b t               end             val bind : 'a t -> ('-> 'b t) -> 'b t             val return : '-> 'a t             val map : 'a t -> f:('-> 'b) -> 'b t             val join : 'a t t -> 'a t             val ignore_m : 'a t -> Monoid.Unit.t t             val all : 'a t list -> 'a list t             val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t             module Let_syntax :               sig                 module Let_syntax :                   sig                     val return : '-> 'a t                     val bind : 'a t -> ('-> 'b t) -> 'b t                     val map : 'a t -> f:('-> 'b) -> 'b t                     val both : 'a t -> 'b t -> ('a * 'b) t                     module Open_on_rhs : sig val return : '-> 'a t end                     module Open_in_body : sig val return : '-> 'a t end                   end               end             module Syntax :               sig                 val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t                 val ( >>| ) : 'a t -> ('-> 'b) -> 'b t                 val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t                 val ( !! ) : '-> 'a t                 val ( !$ ) : ('-> 'b) -> 'a t -> 'b t                 val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t                 val ( !$$$ ) :                   ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t                 val ( !$$$$ ) :                   ('-> '-> '-> '-> 'e) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t                 val ( !$$$$$ ) :                   ('-> '-> '-> '-> '-> 'f) ->                   'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t               end           end       module Minimal2 :         functor (M : Minimal2->           sig             type ('a, 'e) t = ('a, 'e) M.t             val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t             val sequence :               (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t             val forever : ('a, 'e) t -> ('b, 'e) t             module Fn :               sig                 val id : '-> ('a, 'e) t                 val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t                 val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t                 val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t                 val apply_n_times :                   n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t                 val compose :                   ('-> ('c, 'e) t) ->                   ('-> ('b, 'e) t) -> '-> ('c, 'e) t               end             module Pair :               sig                 val fst : ('a * 'b, 'e) t -> ('a, 'e) t                 val snd : ('a * 'b, 'e) t -> ('b, 'e) t               end             module Triple :               sig                 val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t                 val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t                 val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t               end             module Lift :               sig                 val nullary : '-> ('a, 'e) t                 val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t                 val binary :                   ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t                 val ternary :                   ('-> '-> '-> 'd) ->                   ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t                 val quaternary :                   ('-> '-> '-> '-> 'e) ->                   ('a, 's) t ->                   ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t                 val quinary :                   ('-> '-> '-> '-> '-> 'f) ->                   ('a, 's) t ->                   ('b, 's) t ->                   ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t               end             module Exn :               sig                 val expect :                   ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->                   f:(Monoid.Unit.t -> ('a, 's) t) ->                   catch:(exn -> ('a, 's) t) -> ('a, 's) t               end             module Collection :               sig                 module type S =                   sig                     type 'a t                     val all : ('a, 'e) M.t t -> ('a t, 'e) M.t                     val all_ignore :                       ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t                     val sequence :                       (Monoid.Unit.t, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t                     val map :                       'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t                     val iter :                       'a t ->                       f:('-> (Monoid.Unit.t, 'e) M.t) ->                       (Monoid.Unit.t, 'e) M.t                     val fold :                       'a t ->                       init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                     val fold_left :                       'a t ->                       init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t                     val fold_right :                       'a t ->                       f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t                     val reduce :                       'a t ->                       f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t                     val exists :                       'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                     val for_all :                       'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t                     val count :                       'a t ->                       f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t                     val map_reduce :                       (module Monoid.S with type t = 'a) ->                       'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t                     val find :                       'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t                     val find_map :                       'a t ->                       f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t                     val filter :                       'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t                     val filter_map :                       'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t                   end                 module Eager :                   functor (T : Collection.Eager->                     sig                       val all : ('a, 'e) t T.t -> ('T.t, 'e) t                       val all_ignore :                         ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val sequence :                         (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val map :                         'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t                       val iter :                         'T.t ->                         f:('-> (Monoid.Unit.t, 'e) t) ->                         (Monoid.Unit.t, 'e) t                       val fold :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_left :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_right :                         'T.t ->                         f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                       val reduce :                         'T.t ->                         f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                       val exists :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val for_all :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val count :                         'T.t ->                         f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t                       val find :                         'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                       val find_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('b option, 'e) t                       val filter :                         'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t                       val filter_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('T.t, 'e) t                     end                 module Delay :                   functor (T : Collection.Delay->                     sig                       val all : ('a, 'e) t T.t -> ('T.t, 'e) t                       val all_ignore :                         ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val sequence :                         (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t                       val map :                         'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t                       val iter :                         'T.t ->                         f:('-> (Monoid.Unit.t, 'e) t) ->                         (Monoid.Unit.t, 'e) t                       val fold :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_left :                         'T.t ->                         init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                       val fold_right :                         'T.t ->                         f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                       val reduce :                         'T.t ->                         f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                       val exists :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val for_all :                         'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t                       val count :                         'T.t ->                         f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                       val map_reduce :                         (module Monoid.S with type t = 'a) ->                         'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t                       val find :                         'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                       val find_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('b option, 'e) t                       val filter :                         'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t                       val filter_map :                         'T.t ->                         f:('-> ('b option, 'e) t) -> ('T.t, 'e) t                     end               end             module List :               sig                 val all : ('a, 'e) t list -> ('a list, 'e) t                 val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t                 val sequence :                   (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t                 val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t                 val iter :                   'a list ->                   f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t                 val fold :                   'a list ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_left :                   'a list ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_right :                   'a list ->                   f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                 val reduce :                   'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                 val exists :                   'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t                 val for_all :                   'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t                 val count :                   'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t                 val find :                   'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t                 val find_map :                   'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t                 val filter :                   'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t                 val filter_map :                   'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t               end             module Seq :               sig                 val all :                   ('a, 'e) t Core_kernel.Std.Sequence.t ->                   ('Core_kernel.Std.Sequence.t, 'e) t                 val all_ignore :                   ('a, 'e) t Core_kernel.Std.Sequence.t ->                   (Monoid.Unit.t, 'e) t                 val sequence :                   (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->                   (Monoid.Unit.t, 'e) t                 val map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b, 'e) t) ->                   ('Core_kernel.Std.Sequence.t, 'e) t                 val iter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t                 val fold :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_left :                   'Core_kernel.Std.Sequence.t ->                   init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t                 val fold_right :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t                 val reduce :                   'Core_kernel.Std.Sequence.t ->                   f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t                 val exists :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> (bool, 'e) t                 val for_all :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> (bool, 'e) t                 val count :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t                 val map_reduce :                   (module Monoid.S with type t = 'a) ->                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('a, 'e) t) -> ('a, 'e) t                 val find :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) -> ('a option, 'e) t                 val find_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b option, 'e) t) -> ('b option, 'e) t                 val filter :                   'Core_kernel.Std.Sequence.t ->                   f:('-> (bool, 'e) t) ->                   ('Core_kernel.Std.Sequence.t, 'e) t                 val filter_map :                   'Core_kernel.Std.Sequence.t ->                   f:('-> ('b option, 'e) t) ->                   ('Core_kernel.Std.Sequence.t, 'e) t               end             val ( >=> ) :               ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t             val ( !! ) : '-> ('a, 'e) t             val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t             val ( !$$ ) :               ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t             val ( !$$$ ) :               ('-> '-> '-> 'd) ->               ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t             val ( !$$$$ ) :               ('-> '-> '-> '-> 'e) ->               ('a, 's) t ->               ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t             val ( !$$$$$ ) :               ('-> '-> '-> '-> '-> 'f) ->               ('a, 's) t ->               ('b, 's) t ->               ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t             val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t             val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t             module Let_syntax :               sig                 module Let_syntax :                   sig                     val return : '-> ('a, 'e) t                     val bind : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t                     val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t                     val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t                     module Open_on_rhs :                       sig val return : '-> ('a, 'e) t end                     module Open_in_body :                       sig val return : '-> ('a,