Data.Tuple

data Tuple a b

A simple product type for wrapping a pair of component values.

Constructors

• Tuple a b

Instances

• (Show a, Show b) => Show (Tuple a b)

  Allows Tuples to be rendered as a string with show whenever there are Show instances for both component types.

• (Eq a, Eq b) => Eq (Tuple a b)
• (Eq a) => Eq1 (Tuple a)
• (Ord a, Ord b) => Ord (Tuple a b)
• (Ord a) => Ord1 (Tuple a)
• (Bounded a, Bounded b) => Bounded (Tuple a b)
• Semigroupoid Tuple
• (Semigroup a, Semigroup b) => Semigroup (Tuple a b)

  The Semigroup instance enables use of the associative operator <> on Tuples whenever there are Semigroup instances for the component types. The <> operator is applied pairwise, so:

  (Tuple a1 b1) <> (Tuple a2 b2) = Tuple (a1 <> a2) (b1 <> b2)
  

• (Monoid a, Monoid b) => Monoid (Tuple a b)
• (Semiring a, Semiring b) => Semiring (Tuple a b)
• (Ring a, Ring b) => Ring (Tuple a b)
• (CommutativeRing a, CommutativeRing b) => CommutativeRing (Tuple a b)
• (HeytingAlgebra a, HeytingAlgebra b) => HeytingAlgebra (Tuple a b)
• (BooleanAlgebra a, BooleanAlgebra b) => BooleanAlgebra (Tuple a b)
• Functor (Tuple a)
• Invariant (Tuple a)
• Bifunctor Tuple
• (Semigroup a) => Apply (Tuple a)

  The Functor instance allows functions to transform the contents of a Tuple with the <*> operator whenever there is a Semigroup instance for the fst component, so:

  (Tuple a1 f) <*> (Tuple a2 x) == Tuple (a1 <> a2) (f x)
  

• Biapply Tuple
• (Monoid a) => Applicative (Tuple a)
• Biapplicative Tuple
• (Semigroup a) => Bind (Tuple a)
• (Monoid a) => Monad (Tuple a)
• Extend (Tuple a)
• Comonad (Tuple a)
• (Lazy a, Lazy b) => Lazy (Tuple a b)
• Foldable (Tuple a)
• Bifoldable Tuple
• Traversable (Tuple a)
• Bitraversable Tuple
• (TypeEquals a Unit) => Distributive (Tuple a)

fst :: forall b a. Tuple a b -> a

Returns the first component of a tuple.

snd :: forall b a. Tuple a b -> b

Returns the second component of a tuple.

curry :: forall c b a. (Tuple a b -> c) -> a -> b -> c

Turn a function that expects a tuple into a function of two arguments.

uncurry :: forall c b a. (a -> b -> c) -> Tuple a b -> c

Turn a function of two arguments into a function that expects a tuple.

swap :: forall b a. Tuple a b -> Tuple b a

Exchange the first and second components of a tuple.

lookup :: forall f b a. Foldable f => Eq a => a -> f (Tuple a b) -> Maybe b

Lookup a value in a data structure of Tuples, generalizing association lists.