NumHask.Pair

I would have used V2 from the linear package, but wanted to avoid the lens dependency. And there's no canonical treatment out there.

Documentation

newtype Pair a

A pair of a's, implemented as a tuple, but api represented as a Pair of a's.

>>> fmap (+1) (Pair 1 2)
Pair 2 3
>>> pure one :: Pair Int
Pair 1 1
>>> (*) <$> Pair 1 2 <*> pure 2
Pair 2 4
>>> foldr (++) [] (Pair [1,2] [3])
[1,2,3]
>>> Pair "a" "pair" `mappend` pure " " `mappend` Pair "string" "mappended"
Pair "a string" "pair mappended"

As a Ring and Field class

>>> Pair 0 1 + zero
Pair 0 1
>>> Pair 0 1 + Pair 2 3
Pair 2 4
>>> Pair 1 1 - one
Pair 0 0
>>> Pair 0 1 * one
Pair 0 1
>>> Pair 0 1 / one
Pair 0.0 1.0
>>> Pair 11 12 `mod` (pure 6)
Pair 5 0

As a numhask module

>>> Pair 1 2 .+ 3
Pair 4 5

representables

>>> distribute [Pair 1 2, Pair 3 4]
Pair [1,3] [2,4]
>>> index (Pair 'l' 'r') False
'l'

Constructors

Pair' (a, a)

Instances

Monad Pair

Methods

(>>=) :: Pair a -> (a -> Pair b) -> Pair b

(>>) :: Pair a -> Pair b -> Pair b

return :: a -> Pair a

fail :: String -> Pair a

Functor Pair

Methods

fmap :: (a -> b) -> Pair a -> Pair b

(<$) :: a -> Pair b -> Pair a

Applicative Pair

Methods

pure :: a -> Pair a

(<*>) :: Pair (a -> b) -> Pair a -> Pair b

liftA2 :: (a -> b -> c) -> Pair a -> Pair b -> Pair c

(*>) :: Pair a -> Pair b -> Pair b

(<*) :: Pair a -> Pair b -> Pair a

Foldable Pair

Methods

fold :: Monoid m => Pair m -> m

foldMap :: Monoid m => (a -> m) -> Pair a -> m

foldr :: (a -> b -> b) -> b -> Pair a -> b

foldr' :: (a -> b -> b) -> b -> Pair a -> b

foldl :: (b -> a -> b) -> b -> Pair a -> b

foldl' :: (b -> a -> b) -> b -> Pair a -> b

foldr1 :: (a -> a -> a) -> Pair a -> a

foldl1 :: (a -> a -> a) -> Pair a -> a

toList :: Pair a -> [a]

null :: Pair a -> Bool

length :: Pair a -> Int

elem :: Eq a => a -> Pair a -> Bool

maximum :: Ord a => Pair a -> a

minimum :: Ord a => Pair a -> a

sum :: Num a => Pair a -> a

product :: Num a => Pair a -> a

Traversable Pair

Methods

traverse :: Applicative f => (a -> f b) -> Pair a -> f (Pair b)

sequenceA :: Applicative f => Pair (f a) -> f (Pair a)

mapM :: Monad m => (a -> m b) -> Pair a -> m (Pair b)

sequence :: Monad m => Pair (m a) -> m (Pair a)

Distributive Pair

Methods

distribute :: Functor f => f (Pair a) -> Pair (f a)

collect :: Functor f => (a -> Pair b) -> f a -> Pair (f b)

distributeM :: Monad m => m (Pair a) -> Pair (m a)

collectM :: Monad m => (a -> Pair b) -> m a -> Pair (m b)

Representable Pair

Associated Types

type Rep (Pair :: * -> *) :: *

Methods

tabulate :: (Rep Pair -> a) -> Pair a

index :: Pair a -> Rep Pair -> a

Eq1 Pair

Methods

liftEq :: (a -> b -> Bool) -> Pair a -> Pair b -> Bool

Show1 Pair

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Pair a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Pair a] -> ShowS

Singleton Pair

Methods

singleton :: a -> Pair a

Traversable1 Pair

Methods

traverse1 :: Apply f => (a -> f b) -> Pair a -> f (Pair b)

sequence1 :: Apply f => Pair (f b) -> f (Pair b)

Foldable1 Pair

Methods

fold1 :: Semigroup m => Pair m -> m

foldMap1 :: Semigroup m => (a -> m) -> Pair a -> m

toNonEmpty :: Pair a -> NonEmpty a

Apply Pair

Methods

(<.>) :: Pair (a -> b) -> Pair a -> Pair b

(.>) :: Pair a -> Pair b -> Pair b

(<.) :: Pair a -> Pair b -> Pair a

liftF2 :: (a -> b -> c) -> Pair a -> Pair b -> Pair c

Additive a => AdditiveModule Pair a

Methods

(.+) :: Pair a -> a -> Pair a

(+.) :: a -> Pair a -> Pair a

AdditiveGroup a => AdditiveGroupModule Pair a

Methods

(.-) :: Pair a -> a -> Pair a

(-.) :: a -> Pair a -> Pair a

Multiplicative a => MultiplicativeModule Pair a

Methods

(.*) :: Pair a -> a -> Pair a

(*.) :: a -> Pair a -> Pair a

MultiplicativeGroup a => MultiplicativeGroupModule Pair a

Methods

(./) :: Pair a -> a -> Pair a

(/.) :: a -> Pair a -> Pair a

Additive a => AdditiveBasis Pair a

Methods

(.+.) :: Pair a -> Pair a -> Pair a

AdditiveGroup a => AdditiveGroupBasis Pair a

Methods

(.-.) :: Pair a -> Pair a -> Pair a

Multiplicative a => MultiplicativeBasis Pair a

Methods

(.*.) :: Pair a -> Pair a -> Pair a

MultiplicativeGroup a => MultiplicativeGroupBasis Pair a

Methods

(./.) :: Pair a -> Pair a -> Pair a

Eq a => Eq (Pair a)

Methods

(==) :: Pair a -> Pair a -> Bool

(/=) :: Pair a -> Pair a -> Bool

(Eq a, Ord a, Signed a, Additive a) => Ord (Pair a)

L1-based Ord instance

Methods

compare :: Pair a -> Pair a -> Ordering

(<) :: Pair a -> Pair a -> Bool

(<=) :: Pair a -> Pair a -> Bool

(>) :: Pair a -> Pair a -> Bool

(>=) :: Pair a -> Pair a -> Bool

max :: Pair a -> Pair a -> Pair a

min :: Pair a -> Pair a -> Pair a

Show a => Show (Pair a)

Methods

showsPrec :: Int -> Pair a -> ShowS

show :: Pair a -> String

showList :: [Pair a] -> ShowS

Generic (Pair a)

Associated Types

type Rep (Pair a) :: * -> *

Methods

from :: Pair a -> Rep (Pair a) x

to :: Rep (Pair a) x -> Pair a

Semigroup a => Semigroup (Pair a)

Methods

(<>) :: Pair a -> Pair a -> Pair a

sconcat :: NonEmpty (Pair a) -> Pair a

stimes :: Integral b => b -> Pair a -> Pair a

(Semigroup a, Monoid a) => Monoid (Pair a)

Methods

mempty :: Pair a

mappend :: Pair a -> Pair a -> Pair a

mconcat :: [Pair a] -> Pair a

Arbitrary a => Arbitrary (Pair a)

Methods

arbitrary :: Gen (Pair a)

shrink :: Pair a -> [Pair a]

NFData a => NFData (Pair a)

Methods

rnf :: Pair a -> ()

Signed a => Signed (Pair a)

Methods

sign :: Pair a -> Pair a

abs :: Pair a -> Pair a

Epsilon a => Epsilon (Pair a)

Methods

nearZero :: Pair a -> Bool

aboutEqual :: Pair a -> Pair a -> Bool

positive :: Pair a -> Bool

veryPositive :: Pair a -> Bool

veryNegative :: Pair a -> Bool

Semifield a => Semifield (Pair a)

Field a => Field (Pair a)

ExpField a => ExpField (Pair a)

Methods

exp :: Pair a -> Pair a

log :: Pair a -> Pair a

logBase :: Pair a -> Pair a -> Pair a

(**) :: Pair a -> Pair a -> Pair a

sqrt :: Pair a -> Pair a

UpperBoundedField a => UpperBoundedField (Pair a)

Methods

infinity :: Pair a

nan :: Pair a

LowerBoundedField a => LowerBoundedField (Pair a)

Methods

negInfinity :: Pair a

Integral a => Integral (Pair a)

Methods

div :: Pair a -> Pair a -> Pair a

mod :: Pair a -> Pair a -> Pair a

divMod :: Pair a -> Pair a -> (Pair a, Pair a)

quot :: Pair a -> Pair a -> Pair a

rem :: Pair a -> Pair a -> Pair a

quotRem :: Pair a -> Pair a -> (Pair a, Pair a)

Semiring a => Semiring (Pair a)

Ring a => Ring (Pair a)

CRing a => CRing (Pair a)

Distribution a => Distribution (Pair a)

MultiplicativeMagma a => MultiplicativeMagma (Pair a)

Methods

times :: Pair a -> Pair a -> Pair a

MultiplicativeUnital a => MultiplicativeUnital (Pair a)

Methods

one :: Pair a

MultiplicativeMagma a => MultiplicativeAssociative (Pair a)

MultiplicativeMagma a => MultiplicativeCommutative (Pair a)

MultiplicativeInvertible a => MultiplicativeInvertible (Pair a)

Methods

recip :: Pair a -> Pair a

MultiplicativeUnital a => Multiplicative (Pair a)

Methods

(*) :: Pair a -> Pair a -> Pair a

(MultiplicativeUnital a, MultiplicativeInvertible a) => MultiplicativeGroup (Pair a)

Methods

(/) :: Pair a -> Pair a -> Pair a

AdditiveMagma a => AdditiveMagma (Pair a)

Methods

plus :: Pair a -> Pair a -> Pair a

AdditiveUnital a => AdditiveUnital (Pair a)

Methods

zero :: Pair a

AdditiveMagma a => AdditiveAssociative (Pair a)

AdditiveMagma a => AdditiveCommutative (Pair a)

AdditiveInvertible a => AdditiveInvertible (Pair a)

Methods

negate :: Pair a -> Pair a

AdditiveUnital a => Additive (Pair a)

Methods

(+) :: Pair a -> Pair a -> Pair a

(AdditiveUnital a, AdditiveInvertible a) => AdditiveGroup (Pair a)

Methods

(-) :: Pair a -> Pair a -> Pair a

(ExpField a, Normed a a, MultiplicativeUnital a) => Normed (Pair a) a

Methods

normL1 :: Pair a -> a

normL2 :: Pair a -> a

normLp :: a -> Pair a -> a

(ExpField a, Normed a a) => Metric (Pair a) a

Methods

distanceL1 :: Pair a -> Pair a -> a

distanceL2 :: Pair a -> Pair a -> a

distanceLp :: a -> Pair a -> Pair a -> a

AdditiveGroup a => Normed (Rect a) (Pair a)

Methods

normL1 :: Rect a -> Pair a

normL2 :: Rect a -> Pair a

normLp :: Pair a -> Rect a -> Pair a

type Rep Pair

type Rep Pair = Bool

type Rep (Pair a)

type Rep (Pair a) = D1 * (MetaData "Pair" "NumHask.Pair" "numhask-range-0.2.2.1-CuiYZN34Lwi4movg2vrydE" True) (C1 * (MetaCons "Pair'" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (a, a))))

pattern Pair :: a -> a -> Pair a

the preferred pattern