Tuple (p.core.v0.15.1.doc.core.Core.Tuple)

Sourcemodule T2 : sig ... end

Signature for a 2-tuple module

Sourcemodule T3 : sig ... end

Signature for a 3-tuple module

These functors allow users to write:

  module Foo = struct
    include Tuple.Make       (String) (Int)
    include Tuple.Comparator (String) (Int)
    include Tuple.Comparable (String) (Int)
    include Tuple.Hashable   (String) (Int)
    include Tuple.Binable    (String) (Int)
  end

Sourcemodule Make (T1 : sig ... end) (T2 : sig ... end) : sig ... end

Source

module Comparator
  (S1 : Comparator.S)
  (S2 : Comparator.S) : 
  Comparator.S with type t = Make(S1)(S2).t

Sourcemodule type Comparable_sexpable = sig ... end

Source

module Comparable_plain
  (S1 : Comparable.S_plain)
  (S2 : Comparable.S_plain) : 
  sig ... end

Source

module Comparable
  (S1 : Comparable_sexpable)
  (S2 : Comparable_sexpable) : 
  Comparable_sexpable with type t := Make(S1)(S2).t

Sourcemodule type Hashable_sexpable = sig ... end

Source

module Hashable
  (S1 : Hashable_sexpable)
  (S2 : Hashable_sexpable) : 
  Hashable_sexpable with type t := Make(S1)(S2).t

The difference between Hashable and Hashable_t functors is that the former's result type doesn't contain type t and the latter does. Therefore, Hashable can't be used to combine two pairs into 4-tuple. but Hashable_t can. On the other hand result of Hashable_t cannot be combined with Comparable.

Source

module Hashable_t
  (S1 : Hashable_sexpable)
  (S2 : Hashable_sexpable) : 
  Hashable_sexpable with type t = Make(S1)(S2).t

Source

module Sexpable
  (S1 : Sexpable.S)
  (S2 : Sexpable.S) : 
  Sexpable.S with type t := Make(S1)(S2).t

Source

module Binable
  (B1 : Binable.S)
  (B2 : Binable.S) : 
  Binable.S with type t := Make(B1)(B2).t

Source

module Hasher
  (H1 : sig ... end)
  (H2 : sig ... end) : 
  Hashable_sexpable with type t := Make(H1)(H2).t