Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
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
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 HasOrdering a where Source #
lt :: (Applicative f, AsOrdering b) => OrderT b f a Source #
>>>
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 Source #
>>>
isLT LT
True
>>>
isLT GT
False
>>>
isLT EQ
False
ifLT :: AsOrdering x => a -> a -> x -> a Source #
>>>
ifLT 1 2 LT
2>>>
ifLT 1 2 GT
1>>>
ifLT 1 2 EQ
1
eq :: (Applicative f, AsOrdering b) => OrderT b f a Source #
>>>
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 Source #
>>>
isEQ LT
False
>>>
isEQ GT
False
>>>
isEQ EQ
True
ifEQ :: AsOrdering x => a -> a -> x -> a Source #
>>>
ifEQ 1 2 LT
1>>>
ifEQ 1 2 GT
1>>>
ifEQ 1 2 EQ
2
gt :: (Applicative f, AsOrdering b) => OrderT b f a Source #
>>>
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 Source #
>>>
isGT LT
False
>>>
isGT GT
True
>>>
isGT EQ
False
ifGT :: AsOrdering x => a -> a -> x -> a Source #
>>>
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 Source #
\x y -> view order ordOrder x y == x `compare` y
+++ OK, passed 100 tests.
newtype MonadOrderT a f b Source #
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 #
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") :: 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 Source #
>>>
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 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 :: 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 Source #
>>>
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 Source #
>>>
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 Source #
>>>
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)] 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 :: 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 Source #
An alias for areEqual
.