# Module BatTuple.Tuple3

`module Tuple3: `sig` .. `end``

Triples.

• Author(s): Ashish Agarwal

`type `('a, 'b, 'c)` t = `'a * 'b * 'c` `
`val make : `'a -> 'b -> 'c -> 'a * 'b * 'c``
`val first : `'a * 'b * 'c -> 'a``
`val second : `'a * 'b * 'c -> 'b``
`val third : `'a * 'b * 'c -> 'c``
`val get12 : `'a * 'b * 'c -> 'a * 'b``
`val get13 : `'a * 'b * 'c -> 'a * 'c``
`val get23 : `'a * 'b * 'c -> 'b * 'c``
`val map : `('a -> 'd) -> ('b -> 'e) -> ('c -> 'f) -> 'a * 'b * 'c -> 'd * 'e * 'f``
`val mapn : `('a -> 'b) -> 'a * 'a * 'a -> 'b * 'b * 'b``

Like `BatTuple.Tuple3.map` but specialized for tuples with elements of the same type.

`mapn f` is equivalent to `map f f f`.

`val map1 : `('a -> 'd) -> 'a * 'b * 'c -> 'd * 'b * 'c``
`val map2 : `('b -> 'd) -> 'a * 'b * 'c -> 'a * 'd * 'c``
`val map3 : `('c -> 'd) -> 'a * 'b * 'c -> 'a * 'b * 'd``
`val curry : `('a * 'b * 'c -> 'd) -> 'a -> 'b -> 'c -> 'd``
`val uncurry : `('a -> 'b -> 'c -> 'd) -> 'a * 'b * 'c -> 'd``
`val enum : `'a enumerable -> 'a BatEnum.t``
`val of_enum : `'a BatEnum.t -> 'a enumerable``
• Raises `Failure` if enum does not contain at least 3 elements.
`val print : `?first:string ->       ?sep:string ->       ?last:string ->       ('o BatIO.output -> 'a -> unit) ->       ('o BatIO.output -> 'b -> unit) ->       ('o BatIO.output -> 'c -> unit) -> 'o BatIO.output -> 'a * 'b * 'c -> unit``
`val printn : `?first:string ->       ?sep:string ->       ?last:string ->       ('o BatIO.output -> 'a -> unit) -> 'o BatIO.output -> 'a * 'a * 'a -> unit``
`val compare : `?cmp1:('a -> 'a -> int) ->       ?cmp2:('b -> 'b -> int) ->       ?cmp3:('c -> 'c -> int) -> 'a * 'b * 'c -> 'a * 'b * 'c -> int``
`include BatEnum.Enumerable`
`val eq : `'a BatOrd.eq -> 'b BatOrd.eq -> 'c BatOrd.eq -> ('a * 'b * 'c) BatOrd.eq``
`val ord : `'a BatOrd.ord -> 'b BatOrd.ord -> 'c BatOrd.ord -> ('a * 'b * 'c) BatOrd.ord``
`val comp : `'a BatOrd.comp ->       'b BatOrd.comp -> 'c BatOrd.comp -> ('a * 'b * 'c) BatOrd.comp``
`module Eq: `functor (``T1`` : ``BatOrd.Eq``) -> ``functor (``T2`` : ``BatOrd.Eq``) -> ``functor (``T3`` : ``BatOrd.Eq``) -> ``Eq``  with type t = T1.t * T2.t * T3.t``
`module Ord: `functor (``T1`` : ``BatOrd.Ord``) -> ``functor (``T2`` : ``BatOrd.Ord``) -> ``functor (``T3`` : ``BatOrd.Ord``) -> ``Ord``  with type t = T1.t * T2.t * T3.t``
`module Comp: `functor (``T1`` : ``BatOrd.Comp``) -> ``functor (``T2`` : ``BatOrd.Comp``) -> ``functor (``T3`` : ``BatOrd.Comp``) -> ``Comp``  with type t = T1.t * T2.t * T3.t``