LocalDependency.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)

  Allows Tuples to be checked for equality with == and /= whenever there are Eq instances for both component types.

• (Eq a) => Eq1 (Tuple a)
• (Ord a, Ord b) => Ord (Tuple a b)

  Allows Tuples to be compared with compare, >, >=, < and <= whenever there are Ord instances for both component types. To obtain the result, the fsts are compared, and if they are EQual, the snds are compared.

• (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)

  The Functor instance allows functions to transform the contents of a Tuple with the <$> operator, applying the function to the second component, so:

  f <$> (Tuple x y) = Tuple x (f y)
  

• Generic (Tuple a b) _
• Invariant (Tuple a)
• (Semigroup a) => Apply (Tuple a)

  The Apply 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)
  

• (Monoid a) => Applicative (Tuple a)
• (Semigroup a) => Bind (Tuple a)
• (Monoid a) => Monad (Tuple a)
• Extend (Tuple a)
• Comonad (Tuple a)
• (Lazy a, Lazy b) => Lazy (Tuple a b)

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

Returns the first component of a tuple.

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

Returns the second component of a tuple.

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

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

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

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

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

Exchange the first and second components of a tuple.