Module Base__.Applicative

module type Args = Base__.Applicative_intf.Args
module type Args2 = Base__.Applicative_intf.Args2
module type Basic = Base__.Applicative_intf.Basic
module type Basic2 = Base__.Applicative_intf.Basic2
module type Basic2_using_map2 = Base__.Applicative_intf.Basic2_using_map2
module type Basic_using_map2 = Base__.Applicative_intf.Basic_using_map2
module type S = Base__.Applicative_intf.S
module type S2 = Base__.Applicative_intf.S2
module Args_to_Args2 = Base__.Applicative_intf.Args_to_Args2
module S2_to_S = Base__.Applicative_intf.S2_to_S
module S_to_S2 = Base__.Applicative_intf.S_to_S2
module Make : functor (X : Basic) -> S with type a t := a X.t
module Make2 : functor (X : Basic2) -> S2 with type (a, e) t := (a, e) X.t
module Make_using_map2 : functor (X : Basic_using_map2) -> S with type a t := a X.t
module Make2_using_map2 : functor (X : Basic2_using_map2) -> S2 with type (a, e) t := (a, e) X.t
module Make_args : functor (X : S) -> Args with type a arg := a X.t
module Make_args2 : functor (X : S2) -> Args2 with type (a, e) arg := (a, e) X.t

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.

module Of_monad : functor (M : Base.Monad.S) -> S with type a t := a M.t

Every monad is Applicative via:

module Compose : functor (F : S) -> functor (G : S) -> S with type 'a t = 'a F.t G.t
module Pair : functor (F : S) -> functor (G : S) -> S with type 'a t = 'a F.t * 'a G.t
module Const : functor (Monoid : sig ... end) -> S with type 'a t = Monoid.t

Every monoid gives rise to a constant Applicative.