package bastet

  1. Overview
  2. Docs

Module Bastet.Tuple

val first : ('a * 'b) -> 'a
val second : ('a * 'b) -> 'b
val swap : 'a -> 'b -> 'b * 'a
val curry : (('a * 'b) -> 'c) -> 'a -> 'b -> 'c
val uncurry : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c
module type MAGMA_F = functor (First : Interface.MAGMA) -> functor (Second : Interface.MAGMA) -> Interface.MAGMA with type t = First.t * Second.t
module type SEMIGROUP_F = functor (First : Interface.SEMIGROUP) -> functor (Second : Interface.SEMIGROUP) -> Interface.SEMIGROUP with type t = First.t * Second.t
module type MONOID_F = functor (First : Interface.MONOID) -> functor (Second : Interface.MONOID) -> Interface.MONOID with type t = First.t * Second.t
module type FUNCTOR_F = functor (T : Interface.TYPE) -> Interface.FUNCTOR with type 'a t = T.t * 'a
module type APPLY_F = functor (S : Interface.SEMIGROUP) -> Interface.APPLY with type 'a t = S.t * 'a
module type APPLICATIVE_F = functor (M : Interface.MONOID) -> Interface.APPLICATIVE with type 'a t = M.t * 'a
module type MONAD_F = functor (M : Interface.MONOID) -> Interface.MONAD with type 'a t = M.t * 'a
module type FOLDABLE_F = functor (T : Interface.TYPE) -> Interface.FOLDABLE with type 'a t = T.t * 'a
module type EQ_F = functor (First : Interface.EQ) -> functor (Second : Interface.EQ) -> Interface.EQ with type t = First.t * Second.t
module type SHOW_F = functor (First : Interface.SHOW) -> functor (Second : Interface.SHOW) -> Interface.SHOW with type t = First.t * Second.t
module type TRAVERSABLE_F = functor (T : Interface.TYPE) -> functor (A : Interface.APPLICATIVE) -> Interface.TRAVERSABLE with type 'a t = T.t * 'a and type 'a applicative_t = 'a A.t
module Magma : MAGMA_F
module Monoid : MONOID_F
module Apply : APPLY_F
module Monad : MONAD_F
module Eq : EQ_F
module Semigroupoid : Interface.SEMIGROUPOID with type ('a, 'b) t = 'a * 'b
module Show : SHOW_F
module Bifunctor : Interface.BIFUNCTOR with type ('a, 'b) t = 'a * 'b
module Biapply : Interface.BIAPPLY with type ('a, 'b) t = 'a * 'b
module Biapplicative : Interface.BIAPPLICATIVE with type ('a, 'b) t = 'a * 'b
module Bifoldable : Interface.BIFOLDABLE with type ('a, 'b) t = 'a * 'b
module type BITRAVERSABLE_F = functor (A : Interface.APPLICATIVE) -> Interface.BITRAVERSABLE with type 'a applicative_t = 'a A.t and type ('a, 'b) t = 'a * 'b
module Infix : sig ... end