Applicative (reference.base.base.Base.Applicative)

Sourcemodule type Applicative_infix = sig ... end

Sourcemodule type Applicative_infix2 = sig ... end

Sourcemodule type Applicative_infix3 = sig ... end

Sourcemodule type Applicative_infix_local = sig ... end

Sourcemodule type Applicative_infix2_local = sig ... end

Sourcemodule type Basic = sig ... end

Sourcemodule type Basic2 = sig ... end

Sourcemodule type Basic3 = sig ... end

Sourcemodule type Basic_local = sig ... end

Sourcemodule type Basic2_local = sig ... end

Sourcemodule type Basic_using_map2 = sig ... end

Sourcemodule type Basic2_using_map2 = sig ... end

Sourcemodule type Basic3_using_map2 = sig ... end

Sourcemodule type Basic_using_map2_local = sig ... end

Sourcemodule type Basic2_using_map2_local = sig ... end

Sourcemodule type Basic3_using_map2_local = sig ... end

Sourcemodule type Let_syntax = sig ... end

Sourcemodule type Let_syntax2 = sig ... end

Sourcemodule type Let_syntax3 = sig ... end

Sourcemodule type S = sig ... end

Sourcemodule type S2 = sig ... end

Sourcemodule type S3 = sig ... end

Sourcemodule type Lazy_applicative = sig ... end

Sourcemodule type S_local = sig ... end

Sourcemodule type S2_local = sig ... end

Sourcemodule Ident : S_local with type 'a t = 'a

Sourcemodule S2_to_S (T : T.T) (X : S2) : S with type 'a t = ('a, T.t) X.t

Sourcemodule S_to_S2 (X : S) : S2 with type ('a, 'e) t = 'a X.t

Source

module S3_to_S2
  (T : T.T)
  (X : S3) : 
  S2 with type ('a, 'd) t = ('a, 'd, T.t) X.t

Source

module S3_to_S
  (T1 : T.T)
  (T2 : T.T)
  (X : S3) : 
  S with type 'a t = ('a, T1.t, T2.t) X.t

Sourcemodule S2_to_S3 (X : S2) : S3 with type ('a, 'd, 'e) t = ('a, 'd) X.t

Sourcemodule Make (X : Basic) : S with type 'a t := 'a X.t

Sourcemodule Make2 (X : Basic2) : S2 with type ('a, 'e) t := ('a, 'e) X.t

Sourcemodule Make3 (X : Basic3) : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t

Source

module Make_let_syntax
  (X : sig ... end)
  (Intf : sig ... end)
  (Impl : Intf.S) : 
  Let_syntax with type 'a t := 'a X.t with module Open_on_rhs_intf := Intf

Source

module Make_let_syntax2
  (X : sig ... end)
  (Intf : sig ... end)
  (Impl : Intf.S) : 
  Let_syntax2
    with type ('a, 'e) t := ('a, 'e) X.t
    with module Open_on_rhs_intf := Intf

Source

module Make_let_syntax3
  (X : sig ... end)
  (Intf : sig ... end)
  (Impl : Intf.S) : 
  Let_syntax3
    with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t
    with module Open_on_rhs_intf := Intf

Sourcemodule Make_using_map2 (X : Basic_using_map2) : S with type 'a t := 'a X.t

Source

module Make2_using_map2
  (X : Basic2_using_map2) : 
  S2 with type ('a, 'e) t := ('a, 'e) X.t

Source

module Make3_using_map2
  (X : Basic3_using_map2) : 
  S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t

Source

module Make_using_map2_local
  (X : Basic_using_map2_local) : 
  S_local with type 'a t := 'a X.t

Source

module Make2_using_map2_local
  (X : Basic2_using_map2_local) : 
  S2_local with type ('a, 'e) t := ('a, 'e) X.t

Sourcemodule Make3_using_map2_local (X : Basic3_using_map2_local) : sig ... end

The following functors give a sense of what Applicatives one can define.

Of these, Of_monad is likely the most useful. The others are mostly didactic.

Sourcemodule Of_monad (M : Monad.S) : S with type 'a t := 'a M.t

Every monad is Applicative via:

Sourcemodule Of_monad2 (M : Monad.S2) : S2 with type ('a, 'e) t := ('a, 'e) M.t

Sourcemodule Compose (F : S) (G : S) : S with type 'a t = 'a F.t G.t

Sourcemodule Pair (F : S) (G : S) : S with type 'a t = 'a F.t * 'a G.t