Copyright	(c) Justin Le 2018
License	BSD-3
Maintainer	justin@jle.im
Stability	unstable
Portability	portable
Safe Haskell	None
Language	Haskell2010

Data.Ord.OneLiner

Contents

Newtype wrapper
Generics-derived methods
- Eq
- Ord

Description

Derived methods for Eq and Ord, using Generics.OneLiner and GHC.Generics.

Can be used for any types (deriving Generic) where every field is an instance of Eq (or Ord).

Also includes a newtype wrapper that imbues any such data type with instant Eq and Ord instances, which can one day be used with DerivingVia syntax to derive instances automatically.

Synopsis

newtype GOrd a = GOrd {
- getGOrd :: a
}
gEquals :: forall a. (ADT a, Constraints a Eq) => a -> a -> Bool
gNotEquals :: forall a. (ADT a, Constraints a Eq) => a -> a -> Bool
gCompare :: forall a. (ADT a, Constraints a Ord) => a -> a -> Ordering
gLTE :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool
gLT :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool
gGTE :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool
gGT :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool
gMax :: forall a. (ADT a, Constraints a Ord) => a -> a -> a
gMin :: forall a. (ADT a, Constraints a Ord) => a -> a -> a

Newtype wrapper

newtype GOrd a #

If a is a data type whose fields are all instances of Eq, then GOrd a has a Eq instance.

If a is a data type whose fields are all instances of Ord, then GOrd a has a Ord instance.

Will one day be able to be used with DerivingVia syntax, to derive instances automatically.

Constructors

GOrd
Fields getGOrd :: a

Instances

Functor GOrd #
Instance details Defined in Data.Ord.OneLiner Methods fmap :: (a -> b) -> GOrd a -> GOrd b # (<$) :: a -> GOrd b -> GOrd a #
Foldable GOrd #
Instance details Defined in Data.Ord.OneLiner Methods fold :: Monoid m => GOrd m -> m # foldMap :: Monoid m => (a -> m) -> GOrd a -> m # foldr :: (a -> b -> b) -> b -> GOrd a -> b # foldr' :: (a -> b -> b) -> b -> GOrd a -> b # foldl :: (b -> a -> b) -> b -> GOrd a -> b # foldl' :: (b -> a -> b) -> b -> GOrd a -> b # foldr1 :: (a -> a -> a) -> GOrd a -> a # foldl1 :: (a -> a -> a) -> GOrd a -> a # toList :: GOrd a -> [a] # null :: GOrd a -> Bool # length :: GOrd a -> Int # elem :: Eq a => a -> GOrd a -> Bool # maximum :: Ord a => GOrd a -> a # minimum :: Ord a => GOrd a -> a # sum :: Num a => GOrd a -> a # product :: Num a => GOrd a -> a #
Traversable GOrd #
Instance details Defined in Data.Ord.OneLiner Methods traverse :: Applicative f => (a -> f b) -> GOrd a -> f (GOrd b) # sequenceA :: Applicative f => GOrd (f a) -> f (GOrd a) # mapM :: Monad m => (a -> m b) -> GOrd a -> m (GOrd b) # sequence :: Monad m => GOrd (m a) -> m (GOrd a) #
(ADT a, Constraints a Eq) => Eq (GOrd a) #
Instance details Defined in Data.Ord.OneLiner Methods (==) :: GOrd a -> GOrd a -> Bool # (/=) :: GOrd a -> GOrd a -> Bool #
Data a => Data (GOrd a) #
Instance details Defined in Data.Ord.OneLiner Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GOrd a -> c (GOrd a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GOrd a) # toConstr :: GOrd a -> Constr # dataTypeOf :: GOrd a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GOrd a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GOrd a)) # gmapT :: (forall b. Data b => b -> b) -> GOrd a -> GOrd a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GOrd a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GOrd a -> r # gmapQ :: (forall d. Data d => d -> u) -> GOrd a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GOrd a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GOrd a -> m (GOrd a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GOrd a -> m (GOrd a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GOrd a -> m (GOrd a) #
(ADT a, Constraints a Eq, Constraints a Ord) => Ord (GOrd a) #
Instance details Defined in Data.Ord.OneLiner Methods compare :: GOrd a -> GOrd a -> Ordering # (<) :: GOrd a -> GOrd a -> Bool # (<=) :: GOrd a -> GOrd a -> Bool # (>) :: GOrd a -> GOrd a -> Bool # (>=) :: GOrd a -> GOrd a -> Bool # max :: GOrd a -> GOrd a -> GOrd a # min :: GOrd a -> GOrd a -> GOrd a #
Read a => Read (GOrd a) #
Instance details Defined in Data.Ord.OneLiner Methods readsPrec :: Int -> ReadS (GOrd a) # readList :: ReadS [GOrd a] # readPrec :: ReadPrec (GOrd a) # readListPrec :: ReadPrec [GOrd a] #
Show a => Show (GOrd a) #
Instance details Defined in Data.Ord.OneLiner Methods showsPrec :: Int -> GOrd a -> ShowS # show :: GOrd a -> String # showList :: [GOrd a] -> ShowS #
Generic (GOrd a) #
Instance details Defined in Data.Ord.OneLiner Associated Types type Rep (GOrd a) :: * -> * # Methods from :: GOrd a -> Rep (GOrd a) x # to :: Rep (GOrd a) x -> GOrd a #
type Rep (GOrd a) #
Instance details Defined in Data.Ord.OneLiner type Rep (GOrd a) = D1 (MetaData "GOrd" "Data.Ord.OneLiner" "one-liner-instances-0.1.2.1-Dv3q9tqK0TV1BnaWc3qi6n" True) (C1 (MetaCons "GOrd" PrefixI True) (S1 (MetaSel (Just "getGOrd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

Generics-derived methods

Eq

gEquals :: forall a. (ADT a, Constraints a Eq) => a -> a -> Bool #

== implemented by using == between all of the components, lexicographically. First compares constructors.

gNotEquals :: forall a. (ADT a, Constraints a Eq) => a -> a -> Bool #

/= implemented by using /= between all of the components, lexicographically. First compares constructors.

Ord

gCompare :: forall a. (ADT a, Constraints a Ord) => a -> a -> Ordering #

compare implemented by using compare between all of the components, lexicographically. First compares constructors.

gLTE :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool #

<= implemented by using <= between all of the components. First compares constructors.

gLT :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool #

< implemented by using < between all of the components. First compares constructors.

gGTE :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool #

>= implemented by using >= between all of the components. First compares constructors.

gGT :: forall a. (ADT a, Constraints a Ord) => a -> a -> Bool #

> implemented by using > between all of the components. First compares constructors.

gMax :: forall a. (ADT a, Constraints a Ord) => a -> a -> a #

max implemented by using max between all of the components. First compares constructors. If two items are equal, returns the second.

gMin :: forall a. (ADT a, Constraints a Ord) => a -> a -> a #

min implemented by using min between all of the components. First compares constructors. If two items are equal, returns the first.