Module `Higher_kinded`

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

type ('a, 'b, 'witness) t2 = ('a, ('b, 'witness) t) t: If A implements the signature S2, (a, b, A.witness2) t2 is equivalent to (a, b) A.t.

type ('a, 'b, 'c, 'witness) t3 = ('a, 'b, ('c, 'witness) t) t2: If A implements the signature S3, (a, b, c, A.witness3) t3 is equivalent to (a, b, c) A.t.

type ('a, 'b, 'c, 'd, 'witness) t4 = ('a, 'b, 'c, ('d, 'witness) t) t3: If A implements the signature S4, (a, b, c, d, A.witness4) t4 is equivalent to (a, b, c, d) A.t.

type ('a, 'b, 'c, 'd, 'e, 'witness) t5 = ('a, 'b, 'c, 'd, ('e, 'witness) t) t4: If A implements the signature S5, (a, b, c, d, e, A.witness5) t5 is equivalent to (a, b, c, d, e) A.t.

type ('a, 'b, 'c, 'd, 'e, 'f, 'witness) t6 = ('a, 'b, 'c, 'd, 'e, ('f, 'witness) t) t5: If A implements the signature S6, (a, b, c, d, e, f, A.witness6) t6 is equivalent to (a, b, c, d, e, f) A.t.

type ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'witness) t7 = ('a, 'b, 'c, 'd, 'e, 'f, ('g, 'witness) t) t6: If A implements the signature S7, (a, b, c, d, e, f, g, A.witness7) t7 is equivalent to (a, b, c, d, e, f, g) A.t.

type ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'witness) t8 = ('a, 'b, 'c, 'd, 'e, 'f, 'g, ('h, 'witness) t) t7: If A implements the signature S8, (a, b, c, d, e, f, g, h, A.witness8) t8 is equivalent to (a, b, c, d, e, f, g, h) A.t.

module type S = Higher_kinded__.Higher_kinded_intf.S with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module type S2 = Higher_kinded__.Higher_kinded_intf.S2 with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module type S3 = Higher_kinded__.Higher_kinded_intf.S3 with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module type S4 = Higher_kinded__.Higher_kinded_intf.S4 with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module type S5 = Higher_kinded__.Higher_kinded_intf.S5 with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module type S6 = Higher_kinded__.Higher_kinded_intf.S6 with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module type S7 = Higher_kinded__.Higher_kinded_intf.S7 with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module type S8 = Higher_kinded__.Higher_kinded_intf.S8 with type ('a, 'witness) higher_kinded := ('a, 'witness) t

module Make : functor (X : Base.T1) -> S with type 'a t := 'a X.t

module Make2 : functor (X : Base.T2) -> S2 with type ('a, 'z) t := ('a, 'z) X.t

module Make3 : functor (X : Base.T3) -> S3 with type ('a, 'y, 'z) t := ('a, 'y, 'z) X.t

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

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

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

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

module Make8 : functor (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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

t itself has two type parameters, so we might as well implement S2 right here.

include S2 with type ('a, 'witness) S2.t := ('a, 'witness) t