Higher_kinded (p.higher_kinded.v0.15.0.doc.higher_kinded.Higher

Types

Sourcetype 'a t

If A implements the signature S, (a, A.witness1) t is equivalent to a A.t.

If A implements the signature S, ('a, A.higher_kinded) t1 is equivalent to 'a A.t.

Sourcetype ('a, 'witness) t1 = ('a -> 'witness) t

If A implements the signature S2, ('a, 'b, A.higher_kinded) t2 is equivalent to ('a, 'b) A.t.

Sourcetype ('a, 'b, 'witness) t2 = ('a, 'b -> 'witness) t1

If A implements the signature S3, ('a, 'b, 'c, A.higher_kinded) t3 is equivalent to ('a, 'b, 'c) A.t.

Sourcetype ('a, 'b, 'c, 'witness) t3 = ('a, 'b, 'c -> 'witness) t2

If A implements the signature S4, ('a, 'b, 'c, 'd, A.higher_kinded) t4 is equivalent to ('a, 'b, 'c, 'd) A.t.

Sourcetype ('a, 'b, 'c, 'd, 'witness) t4 = ('a, 'b, 'c, 'd -> 'witness) t3

If A implements the signature S5, ('a, 'b, 'c, 'd, 'e, A.higher_kinded) t5 is equivalent to ('a, 'b, 'c, 'd, 'e) A.t.

Sourcetype ('a, 'b, 'c, 'd, 'e, 'witness) t5 = ('a, 'b, 'c, 'd, 'e -> 'witness) t4

If A implements the signature S6, ('a, 'b, 'c, 'd, 'e, 'f, A.higher_kinded) t6 is equivalent to ('a, 'b, 'c, 'd, 'e, 'f) A.t.

Source

type ('a, 'b, 'c, 'd, 'e, 'f, 'witness) t6 =
  ('a, 'b, 'c, 'd, 'e, 'f -> 'witness) t5

If A implements the signature S7, ('a, 'b, 'c, 'd, 'e, 'f, 'g, A.higher_kinded) t7 is equivalent to ('a, 'b, 'c, 'd, 'e, 'f, 'g) A.t.

Source

type ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'witness) t7 =
  ('a, 'b, 'c, 'd, 'e, 'f, 'g -> 'witness) t6

If A implements the signature S8, ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, A.higher_kinded) t8 is equivalent to ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h) A.t.

Source

type ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'witness) t8 =
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h -> 'witness) t7

Signatures

include sig ... end

Sourcemodule type S = sig ... end

Sourcemodule type S2 = sig ... end

Sourcemodule type S3 = sig ... end

Sourcemodule type S4 = sig ... end

Sourcemodule type S5 = sig ... end

Sourcemodule type S6 = sig ... end

Sourcemodule type S7 = sig ... end

Sourcemodule type S8 = sig ... end

Sourcemodule type Monad = sig ... end

Sourcemodule type Monad2 = sig ... end

Sourcemodule type Monad3 = sig ... end

Functors

This is the meat of the library. Use these functors to implement the higher_kinded interface.

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

Sourcemodule Make2 (X : sig ... end) : S2 with type ('a, 'z) t := ('a, 'z) X.t

Source

module Make3
  (X : sig ... end) : 
  S3 with type ('a, 'y, 'z) t := ('a, 'y, 'z) X.t

Source

module Make4
  (X : sig ... end) : 
  S4 with type ('a, 'x, 'y, 'z) t := ('a, 'x, 'y, 'z) X.t

Source

module Make5
  (X : sig ... end) : 
  S5 with type ('a, 'w, 'x, 'y, 'z) t := ('a, 'w, 'x, 'y, 'z) X.t

Source

module Make6
  (X : sig ... end) : 
  S6 with type ('a, 'v, 'w, 'x, 'y, 'z) t := ('a, 'v, 'w, 'x, 'y, 'z) X.t

Source

module Make7
  (X : sig ... end) : 
  S7
    with type ('a, 'u, 'v, 'w, 'x, 'y, 'z) t :=
           ('a, 'u, 'v, 'w, 'x, 'y, 'z) X.t

Source

module Make8
  (X : sig ... end) : 
  S8
    with type ('a, 't, 'u, 'v, 'w, 'x, 'y, 'z) t :=
           ('a, 't, 'u, 'v, 'w, 'x, 'y, 'z) X.t

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

Source

module Make_monad2
  (M : Base.Monad.S2) : 
  Monad2 with type ('a, 'b) t := ('a, 'b) M.t

Source

module Make_monad3
  (M : Base.Monad.S3) : 
  Monad3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t

Source

module Make_monad_using_witness
  (M : Base.Monad.S)
  (X : S with type 'a t := 'a M.t) : 
  Monad with type 'a t := 'a M.t with type higher_kinded := X.higher_kinded

Source

module Make_monad_using_witness2
  (M : Base.Monad.S2)
  (X : S2 with type ('a, 'b) t := ('a, 'b) M.t) : 
  Monad2
    with type ('a, 'b) t := ('a, 'b) M.t
    with type higher_kinded := X.higher_kinded

Source

module Make_monad_using_witness3
  (M : Base.Monad.S3)
  (X : S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t) : 
  Monad3
    with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t
    with type higher_kinded := X.higher_kinded

Implementations

Base, Core, and Async don't depend on Higher_kinded, so we put these implementations here instead of in the respective modules where they might have been a nicer fit.

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

Sourcemodule Array : S with type 'a t := 'a Base.Array.t

Sourcemodule Either : S2 with type ('a, 'b) t := ('a, 'b) Base.Either.t

Sourcemodule Hash_set : S with type 'a t := 'a Base.Hash_set.t

Sourcemodule Hashtbl : S2 with type ('a, 'b) t := ('a, 'b) Base.Hashtbl.t

Sourcemodule Lazy : S with type 'a t := 'a Base.Lazy.t

Sourcemodule List : S with type 'a t := 'a Base.List.t

Sourcemodule Map : S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) Base.Map.t

Sourcemodule Option : S with type 'a t := 'a Base.Option.t

Sourcemodule Queue : S with type 'a t := 'a Base.Queue.t

Sourcemodule Ref : S with type 'a t := 'a Base.Ref.t

Sourcemodule Result : S2 with type ('a, 'e) t := ('a, 'e) Base.Result.t

Sourcemodule Set : S2 with type ('a, 'b) t := ('a, 'b) Base.Set.t

Sourcemodule Sequence : S with type 'a t := 'a Base.Sequence.t

Sourcemodule Type_equal : S2 with type ('a, 'b) t := ('a, 'b) Base.Type_equal.t

t itself has one type parameter, so we might as well implement S right here.

include S with type 'a t := 'a t

Sourcetype higher_kinded

Sourceval inject : 'a t -> ('a -> higher_kinded) t

Sourceval project : ('a -> higher_kinded) t -> 'a t