| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Data.Ord.Ordering
Synopsis
- newtype OrderT b f a = OrderT (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
- class HasOrdering a where
- lt :: (Applicative f, AsOrdering b) => OrderT b f a
- isLT :: AsOrdering a => a -> Bool
- ifLT :: AsOrdering x => a -> a -> x -> a
- eq :: (Applicative f, AsOrdering b) => OrderT b f a
- isEQ :: AsOrdering a => a -> Bool
- ifEQ :: AsOrdering x => a -> a -> x -> a
- gt :: (Applicative f, AsOrdering b) => OrderT b f a
- isGT :: AsOrdering a => a -> Bool
- ifGT :: AsOrdering x => a -> a -> x -> a
- ordOrder :: (Ord a, AsOrdering b, Applicative f) => OrderT b f a
- newtype MonadOrderT a f b = MonadOrderT (OrderT b f a)
- 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 = ProfunctorOrderT (OrderT b f a)
- 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
- ordOrderL :: (Ord a, AsOrdering b) => Getting a s a -> Order b s
- orderS :: Contravariant f => State a b -> f b -> f a
- ordOrderS :: (Ord x, AsOrdering b) => State a x -> Order b a
- orderR :: Contravariant f => Reader a b -> f b -> f a
- ordOrderR :: (Ord x, AsOrdering b, Applicative f) => Reader a x -> OrderT b f a
- perRest :: (Applicative f, Monoid x) => OrderT x f a -> [a] -> f [(a, x)]
- perRest' :: Monoid x => Order x a -> [a] -> [(a, x)]
- duplicates :: (Monad f, AsOrdering b) => OrderT b f a -> [a] -> f [(a, NonEmpty a)]
- duplicates' :: AsOrdering b => Order b a -> [a] -> [(a, NonEmpty a)]
- areEqual :: (Functor f, Eq a, AsOrdering b) => a -> a -> OrderT b f a -> OrderT b f a
- (.===.) :: (Applicative f, Ord a, AsOrdering b) => a -> a -> OrderT b f a
Documentation
>>>import Control.Lens>>>import Control.Monad.State>>>import Data.Eq>>>import Data.Functor.Contravariant
Constructors
| OrderT (a -> a -> f b) |
Instances
| Contravariant (OrderT b f) Source # | |
| (Applicative f, Monoid b) => Divisible (OrderT b f) Source # | |
| (Applicative f, Monoid b) => Monoid (OrderT b f a) Source # | |
| (Applicative f, Semigroup b) => Semigroup (OrderT b f a) Source # | |
| Wrapped (OrderT b f a) Source # | |
| OrderT b' f' a' ~ t => Rewrapped (OrderT b f a) t Source # | |
Defined in Data.Ord.Ordering | |
| type Unwrapped (OrderT b f a) Source # | |
Defined in Data.Ord.Ordering | |
class AsOrdering a where Source #
Minimal complete definition
class HasOrdering a where Source #
lt :: (Applicative f, AsOrdering b) => OrderT b f a Source #
>>>view order lt 1 1 :: OrderingLT
>>>view order lt 1 2 :: OrderingLT
>>>view order lt 2 1 :: OrderingLT
\x y -> (view order lt x y :: Ordering) == LT
+++ OK, passed 100 tests.
isLT :: AsOrdering a => a -> Bool Source #
>>>isLT LTTrue
>>>isLT GTFalse
>>>isLT EQFalse
ifLT :: AsOrdering x => a -> a -> x -> a Source #
>>>ifLT 1 2 LT2>>>ifLT 1 2 GT1>>>ifLT 1 2 EQ1
eq :: (Applicative f, AsOrdering b) => OrderT b f a Source #
>>>view order eq 1 1 :: OrderingEQ
>>>view order eq 1 2 :: OrderingEQ
>>>view order eq 2 1 :: OrderingEQ
\x y -> (view order eq x y :: Ordering) == EQ
+++ OK, passed 100 tests.
isEQ :: AsOrdering a => a -> Bool Source #
>>>isEQ LTFalse
>>>isEQ GTFalse
>>>isEQ EQTrue
ifEQ :: AsOrdering x => a -> a -> x -> a Source #
>>>ifEQ 1 2 LT1>>>ifEQ 1 2 GT1>>>ifEQ 1 2 EQ2
gt :: (Applicative f, AsOrdering b) => OrderT b f a Source #
>>>view order gt 1 1 :: OrderingGT
>>>view order gt 1 2 :: OrderingGT
>>>view order gt 2 1 :: OrderingGT
\x y -> (view order gt x y :: Ordering) == GT
+++ OK, passed 100 tests.
isGT :: AsOrdering a => a -> Bool Source #
>>>isGT LTFalse
>>>isGT GTTrue
>>>isGT EQFalse
ifGT :: AsOrdering x => a -> a -> x -> a Source #
>>>ifGT 1 2 LT1>>>ifGT 1 2 GT2>>>ifGT 1 2 EQ1
ordOrder :: (Ord a, AsOrdering b, Applicative f) => OrderT b f a Source #
\x y -> view order ordOrder x y == x `compare` y
+++ OK, passed 100 tests.
newtype MonadOrderT a f b Source #
Constructors
| MonadOrderT (OrderT b f a) |
Instances
monadOrder :: Iso (OrderT b f a) (OrderT b' f' a') (MonadOrderT a f b) (MonadOrderT a' f' b') Source #
argument1 :: Applicative f => MonadOrderT a f a Source #
argument2 :: Applicative f => MonadOrderT a f a Source #
newtype ProfunctorOrderT f a b Source #
Constructors
| ProfunctorOrderT (OrderT b f a) |
Instances
profunctorOrder :: Iso (OrderT b f a) (OrderT b' f' a') (ProfunctorOrderT f a b) (ProfunctorOrderT f' a' b') Source #
appendOrder :: (Applicative f, Semigroup x) => OrderT x f x Source #
listOrder :: (Applicative f, AsOrdering b, Semigroup b) => OrderT b f a -> OrderT b f [a] Source #
bothOrder' :: Semigroup b => (a -> b) -> Order b a Source #
orderL :: Contravariant f => Getting a s a -> f a -> f s Source #
>>>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") :: OrderingLT
>>>view order (orderL _1 ordOrder) (2, "a") (1, "b") :: OrderingGT
>>>view order (orderL _1 ordOrder) (1, "a") (1, "b") :: OrderingEQ
ordOrderL :: (Ord a, AsOrdering b) => Getting a s a -> Order b s Source #
>>>view order (ordOrderL _1) (1, "a") (2, "b") :: OrderingLT
>>>view order (ordOrderL _1) (2, "a") (1, "b") :: OrderingGT
>>>view order (ordOrderL _1) (1, "a") (1, "b") :: OrderingEQ
orderS :: Contravariant f => State a b -> f b -> f a Source #
>>>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 :: OrderingLT
>>>view order (orderS (state (\s -> (s + 1, s * 2))) ordOrder) 5 4 :: OrderingGT
>>>view order (orderS (state (\s -> (s + 1, s * 2))) ordOrder) 5 5 :: OrderingEQ
ordOrderS :: (Ord x, AsOrdering b) => State a x -> Order b a Source #
>>>view order (ordOrderS (state (\s -> (s + 1, s * 2)))) 5 6 :: OrderingLT
>>>view order (ordOrderS (state (\s -> (s + 1, s * 2)))) 5 4 :: OrderingGT
>>>view order (ordOrderS (state (\s -> (s + 1, s * 2)))) 5 5 :: OrderingEQ
orderR :: Contravariant f => Reader a b -> f b -> f a Source #
>>>getPredicate (orderR (reader (\r -> r + 1)) (Predicate even)) 1True
>>>getPredicate (orderR (reader (\r -> r + 1)) (Predicate even)) 2False
>>>view order (orderR (reader (\r -> r + 1)) ordOrder) 1 0 :: OrderingGT
>>>view order (orderR (reader (\r -> r + 1)) ordOrder) 1 2 :: OrderingLT
>>>view order (orderR (reader (\r -> r + 1)) ordOrder) 2 1 :: OrderingGT
ordOrderR :: (Ord x, AsOrdering b, Applicative f) => Reader a x -> OrderT b f a Source #
>>>view order (ordOrderR (reader (\r -> r + 1))) 1 0 :: OrderingGT
>>>view order (ordOrderR (reader (\r -> r + 1))) 1 2 :: OrderingLT
>>>view order (ordOrderR (reader (\r -> r + 1))) 2 1 :: OrderingGT
perRest :: (Applicative f, Monoid x) => OrderT x f a -> [a] -> f [(a, x)] Source #
>>>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)] Source #
>>>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)] Source #
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)] Source #
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 Source #
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 :: OrderingLT
>>>view order (areEqual 1 2 ordOrder) 4 3 :: OrderingGT
>>>view order (areEqual 1 2 ordOrder) 3 3 :: OrderingEQ
>>>view order (areEqual 1 2 ordOrder) 1 3 :: OrderingLT
>>>view order (areEqual 1 2 ordOrder) 2 3 :: OrderingLT
>>>view order (areEqual 1 2 ordOrder) 1 2 :: OrderingEQ
>>>view order (areEqual 1 2 ordOrder) 2 1 :: OrderingEQ
(.===.) :: (Applicative f, Ord a, AsOrdering b) => a -> a -> OrderT b f a Source #
An alias for areEqual.