Data.Ord.Ordering

Documentation

>>> import Control.Lens
>>> import Control.Monad.State
>>> import Data.Eq
>>> import Data.Functor.Contravariant

newtype OrderT b f a

Constructors

OrderT (a -> a -> f b)

Instances

Contravariant (OrderT b f)

Defined in Data.Ord.Ordering

Methods

contramap :: (a' -> a) -> OrderT b f a -> OrderT b f a'

(>$) :: b0 -> OrderT b f b0 -> OrderT b f a

(Applicative f, Monoid b) => Divisible (OrderT b f)

Defined in Data.Ord.Ordering

Methods

divide :: (a -> (b0, c)) -> OrderT b f b0 -> OrderT b f c -> OrderT b f a

conquer :: OrderT b f a

(Applicative f, Monoid b) => Monoid (OrderT b f a)

Defined in Data.Ord.Ordering

Methods

mempty :: OrderT b f a

mappend :: OrderT b f a -> OrderT b f a -> OrderT b f a

mconcat :: [OrderT b f a] -> OrderT b f a

(Applicative f, Semigroup b) => Semigroup (OrderT b f a)

Defined in Data.Ord.Ordering

Methods

(<>) :: OrderT b f a -> OrderT b f a -> OrderT b f a

sconcat :: NonEmpty (OrderT b f a) -> OrderT b f a

stimes :: Integral b0 => b0 -> OrderT b f a -> OrderT b f a

Wrapped (OrderT b f a)

Defined in Data.Ord.Ordering

Associated Types

type Unwrapped (OrderT b f a)

Methods

_Wrapped' :: Iso' (OrderT b f a) (Unwrapped (OrderT b f a))

OrderT b' f' a' ~ t => Rewrapped (OrderT b f a) t

Defined in Data.Ord.Ordering

type Unwrapped (OrderT b f a)

Defined in Data.Ord.Ordering

type Unwrapped (OrderT b f a) = a -> a -> f b

type Order b a = OrderT b Identity a

order :: Iso (Order b a) (Order b a) (a -> a -> b) (a -> a -> b)

class AsOrdering a where

Minimal complete definition

_Ordering

Methods

_Ordering :: Prism' a Ordering

_LT :: Prism' a ()

_EQ :: Prism' a ()

_GT :: Prism' a ()

Instances

AsOrdering Ordering

Defined in Data.Ord.Ordering

Methods

_Ordering :: Prism' Ordering Ordering

_LT :: Prism' Ordering ()

_EQ :: Prism' Ordering ()

_GT :: Prism' Ordering ()

class HasOrdering a where

Methods

ordering :: Lens' a Ordering

Instances

HasOrdering Ordering

Defined in Data.Ord.Ordering

Methods

ordering :: Lens' Ordering Ordering

lt :: (Applicative f, AsOrdering b) => OrderT b f a

>>> view order lt 1 1 :: Ordering
LT

>>> view order lt 1 2 :: Ordering
LT

>>> view order lt 2 1 :: Ordering
LT

\x y -> (view order lt x y :: Ordering) == LT

+++ OK, passed 100 tests.

isLT :: AsOrdering a => a -> Bool

>>> isLT LT
True

>>> isLT GT
False

>>> isLT EQ
False

ifLT :: AsOrdering x => a -> a -> x -> a

>>> ifLT 1 2 LT
2
>>> ifLT 1 2 GT
1
>>> ifLT 1 2 EQ
1

eq :: (Applicative f, AsOrdering b) => OrderT b f a

>>> view order eq 1 1 :: Ordering
EQ

>>> view order eq 1 2 :: Ordering
EQ

>>> view order eq 2 1 :: Ordering
EQ

\x y -> (view order eq x y :: Ordering) == EQ

+++ OK, passed 100 tests.

isEQ :: AsOrdering a => a -> Bool

>>> isEQ LT
False

>>> isEQ GT
False

>>> isEQ EQ
True

ifEQ :: AsOrdering x => a -> a -> x -> a

>>> ifEQ 1 2 LT
1
>>> ifEQ 1 2 GT
1
>>> ifEQ 1 2 EQ
2

gt :: (Applicative f, AsOrdering b) => OrderT b f a

>>> view order gt 1 1 :: Ordering
GT

>>> view order gt 1 2 :: Ordering
GT

>>> view order gt 2 1 :: Ordering
GT

\x y -> (view order gt x y :: Ordering) == GT

+++ OK, passed 100 tests.

isGT :: AsOrdering a => a -> Bool

>>> isGT LT
False

>>> isGT GT
True

>>> isGT EQ
False

ifGT :: AsOrdering x => a -> a -> x -> a

>>> ifGT 1 2 LT
1
>>> ifGT 1 2 GT
2
>>> ifGT 1 2 EQ
1

ordOrder :: (Ord a, AsOrdering b, Applicative f) => OrderT b f a

\x y -> view order ordOrder x y == x `compare` y

+++ OK, passed 100 tests.

newtype MonadOrderT a f b

Constructors

MonadOrderT (OrderT b f a)

Instances

MonadTrans (MonadOrderT a)

Defined in Data.Ord.Ordering

Methods

lift :: Monad m => m a0 -> MonadOrderT a m a0

MonadIO f => MonadIO (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

liftIO :: IO a0 -> MonadOrderT a f a0

Alternative f => Alternative (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

empty :: MonadOrderT a f a0

(<|>) :: MonadOrderT a f a0 -> MonadOrderT a f a0 -> MonadOrderT a f a0

some :: MonadOrderT a f a0 -> MonadOrderT a f [a0]

many :: MonadOrderT a f a0 -> MonadOrderT a f [a0]

Applicative f => Applicative (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

pure :: a0 -> MonadOrderT a f a0

(<*>) :: MonadOrderT a f (a0 -> b) -> MonadOrderT a f a0 -> MonadOrderT a f b

liftA2 :: (a0 -> b -> c) -> MonadOrderT a f a0 -> MonadOrderT a f b -> MonadOrderT a f c

(*>) :: MonadOrderT a f a0 -> MonadOrderT a f b -> MonadOrderT a f b

(<*) :: MonadOrderT a f a0 -> MonadOrderT a f b -> MonadOrderT a f a0

Functor f => Functor (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

fmap :: (a0 -> b) -> MonadOrderT a f a0 -> MonadOrderT a f b

(<$) :: a0 -> MonadOrderT a f b -> MonadOrderT a f a0

Monad f => Monad (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

(>>=) :: MonadOrderT a f a0 -> (a0 -> MonadOrderT a f b) -> MonadOrderT a f b

(>>) :: MonadOrderT a f a0 -> MonadOrderT a f b -> MonadOrderT a f b

return :: a0 -> MonadOrderT a f a0

Alt f => Alt (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

(<!>) :: MonadOrderT a f a0 -> MonadOrderT a f a0 -> MonadOrderT a f a0

some :: Applicative (MonadOrderT a f) => MonadOrderT a f a0 -> MonadOrderT a f [a0]

many :: Applicative (MonadOrderT a f) => MonadOrderT a f a0 -> MonadOrderT a f [a0]

Apply f => Apply (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

(<.>) :: MonadOrderT a f (a0 -> b) -> MonadOrderT a f a0 -> MonadOrderT a f b

(.>) :: MonadOrderT a f a0 -> MonadOrderT a f b -> MonadOrderT a f b

(<.) :: MonadOrderT a f a0 -> MonadOrderT a f b -> MonadOrderT a f a0

liftF2 :: (a0 -> b -> c) -> MonadOrderT a f a0 -> MonadOrderT a f b -> MonadOrderT a f c

Bind f => Bind (MonadOrderT a f)

Defined in Data.Ord.Ordering

Methods

(>>-) :: MonadOrderT a f a0 -> (a0 -> MonadOrderT a f b) -> MonadOrderT a f b

join :: MonadOrderT a f (MonadOrderT a f a0) -> MonadOrderT a f a0

monadOrder :: Iso (OrderT b f a) (OrderT b' f' a') (MonadOrderT a f b) (MonadOrderT a' f' b')

argument1 :: Applicative f => MonadOrderT a f a

argument2 :: Applicative f => MonadOrderT a f a

newtype ProfunctorOrderT f a b

Constructors

ProfunctorOrderT (OrderT b f a)

Instances

Applicative f => Choice (ProfunctorOrderT f)

Defined in Data.Ord.Ordering

Methods

left' :: ProfunctorOrderT f a b -> ProfunctorOrderT f (Either a c) (Either b c)

right' :: ProfunctorOrderT f a b -> ProfunctorOrderT f (Either c a) (Either c b)

Functor f => Profunctor (ProfunctorOrderT f)

Defined in Data.Ord.Ordering

Methods

dimap :: (a -> b) -> (c -> d) -> ProfunctorOrderT f b c -> ProfunctorOrderT f a d

lmap :: (a -> b) -> ProfunctorOrderT f b c -> ProfunctorOrderT f a c

rmap :: (b -> c) -> ProfunctorOrderT f a b -> ProfunctorOrderT f a c

(#.) :: forall a b c q. Coercible c b => q b c -> ProfunctorOrderT f a b -> ProfunctorOrderT f a c

(.#) :: forall a b c q. Coercible b a => ProfunctorOrderT f b c -> q a b -> ProfunctorOrderT f a c

MonadIO f => MonadIO (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

liftIO :: IO a0 -> ProfunctorOrderT f a a0

Alternative f => Alternative (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

empty :: ProfunctorOrderT f a a0

(<|>) :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a a0 -> ProfunctorOrderT f a a0

some :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a [a0]

many :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a [a0]

Applicative f => Applicative (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

pure :: a0 -> ProfunctorOrderT f a a0

(<*>) :: ProfunctorOrderT f a (a0 -> b) -> ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b

liftA2 :: (a0 -> b -> c) -> ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a c

(*>) :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a b

(<*) :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a a0

Functor f => Functor (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

fmap :: (a0 -> b) -> ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b

(<$) :: a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a a0

Monad f => Monad (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

(>>=) :: ProfunctorOrderT f a a0 -> (a0 -> ProfunctorOrderT f a b) -> ProfunctorOrderT f a b

(>>) :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a b

return :: a0 -> ProfunctorOrderT f a a0

Alt f => Alt (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

(<!>) :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a a0 -> ProfunctorOrderT f a a0

some :: Applicative (ProfunctorOrderT f a) => ProfunctorOrderT f a a0 -> ProfunctorOrderT f a [a0]

many :: Applicative (ProfunctorOrderT f a) => ProfunctorOrderT f a a0 -> ProfunctorOrderT f a [a0]

Apply f => Apply (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

(<.>) :: ProfunctorOrderT f a (a0 -> b) -> ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b

(.>) :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a b

(<.) :: ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a a0

liftF2 :: (a0 -> b -> c) -> ProfunctorOrderT f a a0 -> ProfunctorOrderT f a b -> ProfunctorOrderT f a c

Bind f => Bind (ProfunctorOrderT f a)

Defined in Data.Ord.Ordering

Methods

(>>-) :: ProfunctorOrderT f a a0 -> (a0 -> ProfunctorOrderT f a b) -> ProfunctorOrderT f a b

join :: ProfunctorOrderT f a (ProfunctorOrderT f a a0) -> ProfunctorOrderT f a a0

profunctorOrder :: Iso (OrderT b f a) (OrderT b' f' a') (ProfunctorOrderT f a b) (ProfunctorOrderT f' a' b')

appendOrder :: (Applicative f, Semigroup x) => OrderT x f x

listOrder :: (Applicative f, AsOrdering b, Semigroup b) => OrderT b f a -> OrderT b f [a]

bothOrder :: (Applicative f, Semigroup b) => (a -> f b) -> OrderT b f a

bothOrder' :: Semigroup b => (a -> b) -> Order b a

orderL :: Contravariant f => Getting a s a -> f a -> f s

>>> getPredicate (orderL _1 (Predicate even)) (1, "a")
False

>>> getPredicate (orderL _1 (Predicate even)) (2, "a")
True

>>> view order (orderL _1 ordOrder) (1, "a") (2, "b") :: Ordering
LT

>>> view order (orderL _1 ordOrder) (2, "a") (1, "b") :: Ordering
GT

>>> view order (orderL _1 ordOrder) (1, "a") (1, "b") :: Ordering
EQ

ordOrderL :: (Ord a, AsOrdering b) => Getting a s a -> Order b s

>>> view order (ordOrderL _1) (1, "a") (2, "b") :: Ordering
LT

>>> view order (ordOrderL _1) (2, "a") (1, "b") :: Ordering
GT

>>> view order (ordOrderL _1) (1, "a") (1, "b") :: Ordering
EQ

orderS :: Contravariant f => State a b -> f b -> f a

>>> getPredicate (orderS (state (\s -> (1, reverse s))) (Predicate even)) "abc"
False

>>> getPredicate (orderS (state (\s -> (2, reverse s))) (Predicate even)) "abc"
True

>>> view order (orderS (state (\s -> (s + 1, s * 2))) ordOrder) 5 6 :: Ordering
LT

>>> view order (orderS (state (\s -> (s + 1, s * 2))) ordOrder) 5 4 :: Ordering
GT

>>> view order (orderS (state (\s -> (s + 1, s * 2))) ordOrder) 5 5 :: Ordering
EQ

ordOrderS :: (Ord x, AsOrdering b) => State a x -> Order b a

>>> view order (ordOrderS (state (\s -> (s + 1, s * 2)))) 5 6 :: Ordering
LT

>>> view order (ordOrderS (state (\s -> (s + 1, s * 2)))) 5 4 :: Ordering
GT

>>> view order (ordOrderS (state (\s -> (s + 1, s * 2)))) 5 5 :: Ordering
EQ

orderR :: Contravariant f => Reader a b -> f b -> f a

>>> getPredicate (orderR (reader (\r -> r + 1)) (Predicate even)) 1
True

>>> getPredicate (orderR (reader (\r -> r + 1)) (Predicate even)) 2
False

>>> view order (orderR (reader (\r -> r + 1)) ordOrder) 1 0 :: Ordering
GT

>>> view order (orderR (reader (\r -> r + 1)) ordOrder) 1 2 :: Ordering
LT

>>> view order (orderR (reader (\r -> r + 1)) ordOrder) 2 1 :: Ordering
GT

ordOrderR :: (Ord x, AsOrdering b, Applicative f) => Reader a x -> OrderT b f a

>>> view order (ordOrderR (reader (\r -> r + 1))) 1 0 :: Ordering
GT

>>> view order (ordOrderR (reader (\r -> r + 1))) 1 2 :: Ordering
LT

>>> view order (ordOrderR (reader (\r -> r + 1))) 2 1 :: Ordering
GT

perRest :: (Applicative f, Monoid x) => OrderT x f a -> [a] -> f [(a, x)]

>>> perRest (OrderT (\a1 a2 -> if a1 == 5 then Nothing else Just (a1 `compare` a2))) [5,1,2,3,5,6]
Nothing

>>> perRest (OrderT (\a1 a2 -> if a1 == 5 then Nothing else Just (a1 `compare` a2))) [5,1,2,3,6]
Just [(5,LT),(1,GT),(2,GT),(3,GT),(6,EQ)]

>>> perRest (OrderT (\a1 a2 -> if a1 == 0 then Nothing else Just (a1 `compare` a2))) [5,1,2,3,6]
Just [(5,LT),(1,GT),(2,GT),(3,GT),(6,EQ)]

>>> perRest (OrderT (\a1 a2 -> if a1 == 0 then Nothing else Just (a1 `compare` a2))) [4,5,1,2,3,6]
Just [(4,GT),(5,LT),(1,GT),(2,GT),(3,GT),(6,EQ)]

perRest' :: Monoid x => Order x a -> [a] -> [(a, x)]

>>> perRest' ordOrder [1,2,3,1,3,2,4] :: [(Int, Ordering)]
[(1,GT),(2,GT),(3,LT),(1,GT),(3,LT),(2,GT),(4,EQ)]

duplicates :: (Monad f, AsOrdering b) => OrderT b f a -> [a] -> f [(a, NonEmpty a)]

Returns a list of all elements in a list with at least one duplicate (equal according to Order) in the remainder of the list.

>>> runIdentity (duplicates (ordOrder :: Order Ordering Int) [])
[]

>>> runIdentity (duplicates (ordOrder :: Order Ordering Int) [1..10])
[]

>>> runIdentity (duplicates (ordOrder :: Order Ordering Int) [1,2,3,1])
[(1,1 :| [])]

>>> runIdentity (duplicates (ordOrder :: Order Ordering Int) [1,2,3,1,4,5,1])
[(1,1 :| [1]),(1,1 :| [])]

>>> runIdentity (duplicates (ordOrder :: Order Ordering Int) [1,2,3,1,4,5,1,2,6,7,2,1])
[(1,1 :| [1,1]),(2,2 :| [2]),(1,1 :| [1]),(1,1 :| []),(2,2 :| [])]

duplicates' :: AsOrdering b => Order b a -> [a] -> [(a, NonEmpty a)]

Returns a list of all elements in a list with at least one duplicate (equal according to Order) in the remainder of the list.

>>> duplicates' (ordOrder :: Order Ordering Int) []
[]

>>> duplicates' (ordOrder :: Order Ordering Int) [1..10]
[]

>>> duplicates' (ordOrder :: Order Ordering Int) [1,2,3,1]
[(1,1 :| [])]

>>> duplicates' (ordOrder :: Order Ordering Int) [1,2,3,1,4,5,1]
[(1,1 :| [1]),(1,1 :| [])]

>>> duplicates' (ordOrder :: Order Ordering Int) [1,2,3,1,4,5,1,2,6,7,2,1]
[(1,1 :| [1,1]),(2,2 :| [2]),(1,1 :| [1]),(1,1 :| []),(2,2 :| [])]

areEqual :: (Functor f, Eq a, AsOrdering b) => a -> a -> OrderT b f a -> OrderT b f a

Asserts that the two given values (by the Eq instance) are equal in the Order regardless of the function of the Order

>>> view order (areEqual 1 2 ordOrder) 3 4 :: Ordering
LT

>>> view order (areEqual 1 2 ordOrder) 4 3 :: Ordering
GT

>>> view order (areEqual 1 2 ordOrder) 3 3 :: Ordering
EQ

>>> view order (areEqual 1 2 ordOrder) 1 3 :: Ordering
LT

>>> view order (areEqual 1 2 ordOrder) 2 3 :: Ordering
LT

>>> view order (areEqual 1 2 ordOrder) 1 2 :: Ordering
EQ

>>> view order (areEqual 1 2 ordOrder) 2 1 :: Ordering
EQ

(.===.) :: (Applicative f, Ord a, AsOrdering b) => a -> a -> OrderT b f a

An alias for areEqual.