Methods

(<>) ::Ordering ->Ordering ->OrderingSource#

sconcat ::NonEmptyOrdering ->OrderingSource#

stimes ::Integral b => b ->Ordering ->OrderingSource#

Methods

(<>) :: () -> () -> ()Source#

sconcat ::NonEmpty () -> ()Source#

stimes ::Integral b => b -> () -> ()Source#

Methods

(<>) ::Any ->Any ->AnySource#

sconcat ::NonEmptyAny ->AnySource#

stimes ::Integral b => b ->Any ->AnySource#

Methods

(<>) ::All ->All ->AllSource#

sconcat ::NonEmptyAll ->AllSource#

stimes ::Integral b => b ->All ->AllSource#

Methods

(<>) ::Lifetime ->Lifetime ->LifetimeSource#

sconcat ::NonEmptyLifetime ->LifetimeSource#

stimes ::Integral b => b ->Lifetime ->LifetimeSource#

Methods

(<>) ::Event ->Event ->EventSource#

sconcat ::NonEmptyEvent ->EventSource#

stimes ::Integral b => b ->Event ->EventSource#

Methods

(<>) ::Void ->Void ->VoidSource#

sconcat ::NonEmptyVoid ->VoidSource#

stimes ::Integral b => b ->Void ->VoidSource#

Methods

(<>) :: [a] -> [a] -> [a]Source#

sconcat ::NonEmpty [a] -> [a]Source#

stimes ::Integral b => b -> [a] -> [a]Source#

Methods

(<>) ::Maybe a ->Maybe a ->Maybe aSource#

sconcat ::NonEmpty (Maybe a) ->Maybe aSource#

stimes ::Integral b => b ->Maybe a ->Maybe aSource#

Methods

(<>) ::IO a ->IO a ->IO aSource#

sconcat ::NonEmpty (IO a) ->IO aSource#

stimes ::Integral b => b ->IO a ->IO aSource#

Methods

(<>) ::Par1 p ->Par1 p ->Par1 pSource#

sconcat ::NonEmpty (Par1 p) ->Par1 pSource#

stimes ::Integral b => b ->Par1 p ->Par1 pSource#

Methods

(<>) ::NonEmpty a ->NonEmpty a ->NonEmpty aSource#

sconcat ::NonEmpty (NonEmpty a) ->NonEmpty aSource#

stimes ::Integral b => b ->NonEmpty a ->NonEmpty aSource#

Methods

(<>) ::Down a ->Down a ->Down aSource#

sconcat ::NonEmpty (Down a) ->Down aSource#

stimes ::Integral b => b ->Down a ->Down aSource#

Methods

(<>) ::Product a ->Product a ->Product aSource#

sconcat ::NonEmpty (Product a) ->Product aSource#

stimes ::Integral b => b ->Product a ->Product aSource#

Methods

(<>) ::Sum a ->Sum a ->Sum aSource#

sconcat ::NonEmpty (Sum a) ->Sum aSource#

stimes ::Integral b => b ->Sum a ->Sum aSource#

Methods

(<>) ::Endo a ->Endo a ->Endo aSource#

sconcat ::NonEmpty (Endo a) ->Endo aSource#

stimes ::Integral b => b ->Endo a ->Endo aSource#

Methods

(<>) ::Dual a ->Dual a ->Dual aSource#

sconcat ::NonEmpty (Dual a) ->Dual aSource#

stimes ::Integral b => b ->Dual a ->Dual aSource#

Methods

(<>) ::Last a ->Last a ->Last aSource#

sconcat ::NonEmpty (Last a) ->Last aSource#

stimes ::Integral b => b ->Last a ->Last aSource#

Methods

(<>) ::First a ->First a ->First aSource#

sconcat ::NonEmpty (First a) ->First aSource#

stimes ::Integral b => b ->First a ->First aSource#

Methods

(<>) ::Identity a ->Identity a ->Identity aSource#

sconcat ::NonEmpty (Identity a) ->Identity aSource#

stimes ::Integral b => b ->Identity a ->Identity aSource#

Methods

(<>) ::Option a ->Option a ->Option aSource#

sconcat ::NonEmpty (Option a) ->Option aSource#

stimes ::Integral b => b ->Option a ->Option aSource#

Methods

(<>) ::WrappedMonoid m ->WrappedMonoid m ->WrappedMonoid mSource#

sconcat ::NonEmpty (WrappedMonoid m) ->WrappedMonoid mSource#

stimes ::Integral b => b ->WrappedMonoid m ->WrappedMonoid mSource#

Methods

(<>) ::Last a ->Last a ->Last aSource#

sconcat ::NonEmpty (Last a) ->Last aSource#

stimes ::Integral b => b ->Last a ->Last aSource#

Methods

(<>) ::First a ->First a ->First aSource#

sconcat ::NonEmpty (First a) ->First aSource#

stimes ::Integral b => b ->First a ->First aSource#

Methods

(<>) ::Max a ->Max a ->Max aSource#

sconcat ::NonEmpty (Max a) ->Max aSource#

stimes ::Integral b => b ->Max a ->Max aSource#

Methods

(<>) ::Min a ->Min a ->Min aSource#

sconcat ::NonEmpty (Min a) ->Min aSource#

stimes ::Integral b => b ->Min a ->Min aSource#

Methods

(<>) ::Equivalence a ->Equivalence a ->Equivalence aSource#

sconcat ::NonEmpty (Equivalence a) ->Equivalence aSource#

stimes ::Integral b => b ->Equivalence a ->Equivalence aSource#

Methods

(<>) ::Comparison a ->Comparison a ->Comparison aSource#

sconcat ::NonEmpty (Comparison a) ->Comparison aSource#

stimes ::Integral b => b ->Comparison a ->Comparison aSource#

Methods

(<>) ::Predicate a ->Predicate a ->Predicate aSource#

sconcat ::NonEmpty (Predicate a) ->Predicate aSource#

stimes ::Integral b => b ->Predicate a ->Predicate aSource#

Methods

(<>) :: (a -> b) -> (a -> b) -> a -> bSource#

sconcat ::NonEmpty (a -> b) -> a -> bSource#

stimes ::Integral b0 => b0 -> (a -> b) -> a -> bSource#

Methods

(<>) ::Either a b ->Either a b ->Either a bSource#

sconcat ::NonEmpty (Either a b) ->Either a bSource#

stimes ::Integral b0 => b0 ->Either a b ->Either a bSource#

Methods

(<>) ::V1 p ->V1 p ->V1 pSource#

sconcat ::NonEmpty (V1 p) ->V1 pSource#

stimes ::Integral b => b ->V1 p ->V1 pSource#

Methods

(<>) ::U1 p ->U1 p ->U1 pSource#

sconcat ::NonEmpty (U1 p) ->U1 pSource#

stimes ::Integral b => b ->U1 p ->U1 pSource#

Methods

(<>) :: (a, b) -> (a, b) -> (a, b)Source#

sconcat ::NonEmpty (a, b) -> (a, b)Source#

stimes ::Integral b0 => b0 -> (a, b) -> (a, b)Source#

Methods

(<>) ::ST s a ->ST s a ->ST s aSource#

sconcat ::NonEmpty (ST s a) ->ST s aSource#

stimes ::Integral b => b ->ST s a ->ST s aSource#

Methods

(<>) ::Proxy s ->Proxy s ->Proxy sSource#

sconcat ::NonEmpty (Proxy s) ->Proxy sSource#

stimes ::Integral b => b ->Proxy s ->Proxy sSource#

Methods

(<>) ::Op a b ->Op a b ->Op a bSource#

sconcat ::NonEmpty (Op a b) ->Op a bSource#

stimes ::Integral b0 => b0 ->Op a b ->Op a bSource#

Methods

(<>) ::Rec1 f p ->Rec1 f p ->Rec1 f pSource#

sconcat ::NonEmpty (Rec1 f p) ->Rec1 f pSource#

stimes ::Integral b => b ->Rec1 f p ->Rec1 f pSource#

Methods

(<>) :: (a, b, c) -> (a, b, c) -> (a, b, c)Source#

sconcat ::NonEmpty (a, b, c) -> (a, b, c)Source#

stimes ::Integral b0 => b0 -> (a, b, c) -> (a, b, c)Source#

Methods

(<>) ::Alt f a ->Alt f a ->Alt f aSource#

sconcat ::NonEmpty (Alt f a) ->Alt f aSource#

stimes ::Integral b => b ->Alt f a ->Alt f aSource#

Methods

(<>) ::Ap f a ->Ap f a ->Ap f aSource#

sconcat ::NonEmpty (Ap f a) ->Ap f aSource#

stimes ::Integral b => b ->Ap f a ->Ap f aSource#

Methods

(<>) ::Const a b ->Const a b ->Const a bSource#

sconcat ::NonEmpty (Const a b) ->Const a bSource#

stimes ::Integral b0 => b0 ->Const a b ->Const a bSource#

Methods

(<>) ::K1 i c p ->K1 i c p ->K1 i c pSource#

sconcat ::NonEmpty (K1 i c p) ->K1 i c pSource#

stimes ::Integral b => b ->K1 i c p ->K1 i c pSource#

Methods

(<>) :: (f:*: g) p -> (f:*: g) p -> (f:*: g) pSource#

sconcat ::NonEmpty ((f:*: g) p) -> (f:*: g) pSource#

stimes ::Integral b => b -> (f:*: g) p -> (f:*: g) pSource#

Methods

(<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)Source#

sconcat ::NonEmpty (a, b, c, d) -> (a, b, c, d)Source#

stimes ::Integral b0 => b0 -> (a, b, c, d) -> (a, b, c, d)Source#

Methods

(<>) ::M1 i c f p ->M1 i c f p ->M1 i c f pSource#

sconcat ::NonEmpty (M1 i c f p) ->M1 i c f pSource#

stimes ::Integral b => b ->M1 i c f p ->M1 i c f pSource#

Methods

(<>) :: (f:.: g) p -> (f:.: g) p -> (f:.: g) pSource#

sconcat ::NonEmpty ((f:.: g) p) -> (f:.: g) pSource#

stimes ::Integral b => b -> (f:.: g) p -> (f:.: g) pSource#

Methods

(<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)Source#

sconcat ::NonEmpty (a, b, c, d, e) -> (a, b, c, d, e)Source#

stimes ::Integral b0 => b0 -> (a, b, c, d, e) -> (a, b, c, d, e)Source#

Methods

(>>=) ::Min a -> (a ->Min b) ->Min bSource#

(>>) ::Min a ->Min b ->Min bSource#

return :: a ->Min aSource#

fail ::String ->Min aSource#

Methods

fmap :: (a -> b) ->Min a ->Min bSource#

(<$) :: a ->Min b ->Min aSource#

Methods

mfix :: (a ->Min a) ->Min aSource#

Methods

pure :: a ->Min aSource#

(<*>) ::Min (a -> b) ->Min a ->Min bSource#

liftA2 :: (a -> b -> c) ->Min a ->Min b ->Min cSource#

(*>) ::Min a ->Min b ->Min bSource#

(<*) ::Min a ->Min b ->Min aSource#

Methods

fold ::Monoid m =>Min m -> mSource#

foldMap ::Monoid m => (a -> m) ->Min a -> mSource#

foldr :: (a -> b -> b) -> b ->Min a -> bSource#

foldr' :: (a -> b -> b) -> b ->Min a -> bSource#

foldl :: (b -> a -> b) -> b ->Min a -> bSource#

foldl' :: (b -> a -> b) -> b ->Min a -> bSource#

foldr1 :: (a -> a -> a) ->Min a -> aSource#

foldl1 :: (a -> a -> a) ->Min a -> aSource#

toList ::Min a -> [a]Source#

null ::Min a ->BoolSource#

length ::Min a ->IntSource#

elem ::Eq a => a ->Min a ->BoolSource#

maximum ::Ord a =>Min a -> aSource#

minimum ::Ord a =>Min a -> aSource#

sum ::Num a =>Min a -> aSource#

product ::Num a =>Min a -> aSource#

Methods

traverse ::Applicative f => (a -> f b) ->Min a -> f (Min b)Source#

sequenceA ::Applicative f =>Min (f a) -> f (Min a)Source#

mapM ::Monad m => (a -> m b) ->Min a -> m (Min b)Source#

sequence ::Monad m =>Min (m a) -> m (Min a)Source#

Methods

minBound ::Min aSource#

maxBound ::Min aSource#

Methods

succ ::Min a ->Min aSource#

pred ::Min a ->Min aSource#

toEnum ::Int ->Min aSource#

fromEnum ::Min a ->IntSource#

enumFrom ::Min a -> [Min a]Source#

enumFromThen ::Min a ->Min a -> [Min a]Source#

enumFromTo ::Min a ->Min a -> [Min a]Source#

enumFromThenTo ::Min a ->Min a ->Min a -> [Min a]Source#

Methods

(==) ::Min a ->Min a ->Bool#

(/=) ::Min a ->Min a ->Bool#

Methods

gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Min a -> c (Min a)Source#

gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Min a)Source#

toConstr ::Min a ->ConstrSource#

dataTypeOf ::Min a ->DataTypeSource#

dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Min a))Source#

dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Min a))Source#

gmapT :: (forall b.Data b => b -> b) ->Min a ->Min aSource#

gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Min a -> rSource#

gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Min a -> rSource#

gmapQ :: (forall d.Data d => d -> u) ->Min a -> [u]Source#

gmapQi ::Int -> (forall d.Data d => d -> u) ->Min a -> uSource#

gmapM ::Monad m => (forall d.Data d => d -> m d) ->Min a -> m (Min a)Source#

gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Min a -> m (Min a)Source#

gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Min a -> m (Min a)Source#

Methods

(+) ::Min a ->Min a ->Min aSource#

(-) ::Min a ->Min a ->Min aSource#

(*) ::Min a ->Min a ->Min aSource#

negate ::Min a ->Min aSource#

abs ::Min a ->Min aSource#

signum ::Min a ->Min aSource#

fromInteger ::Integer ->Min aSource#

Methods

compare ::Min a ->Min a ->Ordering#

(<) ::Min a ->Min a ->Bool#

(<=) ::Min a ->Min a ->Bool#

(>) ::Min a ->Min a ->Bool#

(>=) ::Min a ->Min a ->Bool#

max ::Min a ->Min a ->Min a#

min ::Min a ->Min a ->Min a#

Methods

readsPrec ::Int ->ReadS (Min a)Source#

readList ::ReadS [Min a]Source#

readPrec ::ReadPrec (Min a)Source#

readListPrec ::ReadPrec [Min a]Source#

Methods

showsPrec ::Int ->Min a ->ShowSSource#

show ::Min a ->StringSource#

showList :: [Min a] ->ShowSSource#

Associated Types

typeRep (Min a) ::Type ->TypeSource#

Methods

from ::Min a ->Rep (Min a) xSource#

to ::Rep (Min a) x ->Min aSource#

Methods

(<>) ::Min a ->Min a ->Min aSource#

sconcat ::NonEmpty (Min a) ->Min aSource#

stimes ::Integral b => b ->Min a ->Min aSource#

Methods

mempty ::Min aSource#

mappend ::Min a ->Min a ->Min aSource#

mconcat :: [Min a] ->Min aSource#

Associated Types

typeRep1Min :: k ->TypeSource#

Methods

from1 ::Min a ->Rep1Min aSource#

to1 ::Rep1Min a ->Min aSource#

Methods

(>>=) ::Max a -> (a ->Max b) ->Max bSource#

(>>) ::Max a ->Max b ->Max bSource#

return :: a ->Max aSource#

fail ::String ->Max aSource#

Methods

fmap :: (a -> b) ->Max a ->Max bSource#

(<$) :: a ->Max b ->Max aSource#

Methods

mfix :: (a ->Max a) ->Max aSource#

Methods

pure :: a ->Max aSource#

(<*>) ::Max (a -> b) ->Max a ->Max bSource#

liftA2 :: (a -> b -> c) ->Max a ->Max b ->Max cSource#

(*>) ::Max a ->Max b ->Max bSource#

(<*) ::Max a ->Max b ->Max aSource#

Methods

fold ::Monoid m =>Max m -> mSource#

foldMap ::Monoid m => (a -> m) ->Max a -> mSource#

foldr :: (a -> b -> b) -> b ->Max a -> bSource#

foldr' :: (a -> b -> b) -> b ->Max a -> bSource#

foldl :: (b -> a -> b) -> b ->Max a -> bSource#

foldl' :: (b -> a -> b) -> b ->Max a -> bSource#

foldr1 :: (a -> a -> a) ->Max a -> aSource#

foldl1 :: (a -> a -> a) ->Max a -> aSource#

toList ::Max a -> [a]Source#

null ::Max a ->BoolSource#

length ::Max a ->IntSource#

elem ::Eq a => a ->Max a ->BoolSource#

maximum ::Ord a =>Max a -> aSource#

minimum ::Ord a =>Max a -> aSource#

sum ::Num a =>Max a -> aSource#

product ::Num a =>Max a -> aSource#

Methods

traverse ::Applicative f => (a -> f b) ->Max a -> f (Max b)Source#

sequenceA ::Applicative f =>Max (f a) -> f (Max a)Source#

mapM ::Monad m => (a -> m b) ->Max a -> m (Max b)Source#

sequence ::Monad m =>Max (m a) -> m (Max a)Source#

Methods

minBound ::Max aSource#

maxBound ::Max aSource#

Methods

succ ::Max a ->Max aSource#

pred ::Max a ->Max aSource#

toEnum ::Int ->Max aSource#

fromEnum ::Max a ->IntSource#

enumFrom ::Max a -> [Max a]Source#

enumFromThen ::Max a ->Max a -> [Max a]Source#

enumFromTo ::Max a ->Max a -> [Max a]Source#

enumFromThenTo ::Max a ->Max a ->Max a -> [Max a]Source#

Methods

(==) ::Max a ->Max a ->Bool#

(/=) ::Max a ->Max a ->Bool#

Methods

gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Max a -> c (Max a)Source#

gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Max a)Source#

toConstr ::Max a ->ConstrSource#

dataTypeOf ::Max a ->DataTypeSource#

dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Max a))Source#

dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Max a))Source#

gmapT :: (forall b.Data b => b -> b) ->Max a ->Max aSource#

gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Max a -> rSource#

gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Max a -> rSource#

gmapQ :: (forall d.Data d => d -> u) ->Max a -> [u]Source#

gmapQi ::Int -> (forall d.Data d => d -> u) ->Max a -> uSource#

gmapM ::Monad m => (forall d.Data d => d -> m d) ->Max a -> m (Max a)Source#

gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Max a -> m (Max a)Source#

gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Max a -> m (Max a)Source#

Methods

(+) ::Max a ->Max a ->Max aSource#

(-) ::Max a ->Max a ->Max aSource#

(*) ::Max a ->Max a ->Max aSource#

negate ::Max a ->Max aSource#

abs ::Max a ->Max aSource#

signum ::Max a ->Max aSource#

fromInteger ::Integer ->Max aSource#

Methods

compare ::Max a ->Max a ->Ordering#

(<) ::Max a ->Max a ->Bool#

(<=) ::Max a ->Max a ->Bool#

(>) ::Max a ->Max a ->Bool#

(>=) ::Max a ->Max a ->Bool#

max ::Max a ->Max a ->Max a#

min ::Max a ->Max a ->Max a#

Methods

readsPrec ::Int ->ReadS (Max a)Source#

readList ::ReadS [Max a]Source#

readPrec ::ReadPrec (Max a)Source#

readListPrec ::ReadPrec [Max a]Source#

Methods

showsPrec ::Int ->Max a ->ShowSSource#

show ::Max a ->StringSource#

showList :: [Max a] ->ShowSSource#

Associated Types

typeRep (Max a) ::Type ->TypeSource#

Methods

from ::Max a ->Rep (Max a) xSource#

to ::Rep (Max a) x ->Max aSource#

Methods

(<>) ::Max a ->Max a ->Max aSource#

sconcat ::NonEmpty (Max a) ->Max aSource#

stimes ::Integral b => b ->Max a ->Max aSource#

Methods

mempty ::Max aSource#

mappend ::Max a ->Max a ->Max aSource#

mconcat :: [Max a] ->Max aSource#

Associated Types

typeRep1Max :: k ->TypeSource#

Methods

from1 ::Max a ->Rep1Max aSource#

to1 ::Rep1Max a ->Max aSource#

Methods

(>>=) ::First a -> (a ->First b) ->First bSource#

(>>) ::First a ->First b ->First bSource#

return :: a ->First aSource#

fail ::String ->First aSource#

Methods

fmap :: (a -> b) ->First a ->First bSource#

(<$) :: a ->First b ->First aSource#

Methods

mfix :: (a ->First a) ->First aSource#

Methods

pure :: a ->First aSource#

(<*>) ::First (a -> b) ->First a ->First bSource#

liftA2 :: (a -> b -> c) ->First a ->First b ->First cSource#

(*>) ::First a ->First b ->First bSource#

(<*) ::First a ->First b ->First aSource#

Methods

fold ::Monoid m =>First m -> mSource#

foldMap ::Monoid m => (a -> m) ->First a -> mSource#

foldr :: (a -> b -> b) -> b ->First a -> bSource#

foldr' :: (a -> b -> b) -> b ->First a -> bSource#

foldl :: (b -> a -> b) -> b ->First a -> bSource#

foldl' :: (b -> a -> b) -> b ->First a -> bSource#

foldr1 :: (a -> a -> a) ->First a -> aSource#

foldl1 :: (a -> a -> a) ->First a -> aSource#

toList ::First a -> [a]Source#

null ::First a ->BoolSource#

length ::First a ->IntSource#

elem ::Eq a => a ->First a ->BoolSource#

maximum ::Ord a =>First a -> aSource#

minimum ::Ord a =>First a -> aSource#

sum ::Num a =>First a -> aSource#

product ::Num a =>First a -> aSource#

Methods

traverse ::Applicative f => (a -> f b) ->First a -> f (First b)Source#

sequenceA ::Applicative f =>First (f a) -> f (First a)Source#

mapM ::Monad m => (a -> m b) ->First a -> m (First b)Source#

sequence ::Monad m =>First (m a) -> m (First a)Source#

Methods

minBound ::First aSource#

maxBound ::First aSource#

Methods

succ ::First a ->First aSource#

pred ::First a ->First aSource#

toEnum ::Int ->First aSource#

fromEnum ::First a ->IntSource#

enumFrom ::First a -> [First a]Source#

enumFromThen ::First a ->First a -> [First a]Source#

enumFromTo ::First a ->First a -> [First a]Source#

enumFromThenTo ::First a ->First a ->First a -> [First a]Source#

Methods

(==) ::First a ->First a ->Bool#

(/=) ::First a ->First a ->Bool#

Methods

gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->First a -> c (First a)Source#

gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (First a)Source#

toConstr ::First a ->ConstrSource#

dataTypeOf ::First a ->DataTypeSource#

dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (First a))Source#

dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (First a))Source#

gmapT :: (forall b.Data b => b -> b) ->First a ->First aSource#

gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->First a -> rSource#

gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->First a -> rSource#

gmapQ :: (forall d.Data d => d -> u) ->First a -> [u]Source#

gmapQi ::Int -> (forall d.Data d => d -> u) ->First a -> uSource#

gmapM ::Monad m => (forall d.Data d => d -> m d) ->First a -> m (First a)Source#

gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->First a -> m (First a)Source#

gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->First a -> m (First a)Source#

Methods

compare ::First a ->First a ->Ordering#

(<) ::First a ->First a ->Bool#

(<=) ::First a ->First a ->Bool#

(>) ::First a ->First a ->Bool#

(>=) ::First a ->First a ->Bool#

max ::First a ->First a ->First a#

min ::First a ->First a ->First a#

Methods

readsPrec ::Int ->ReadS (First a)Source#

readList ::ReadS [First a]Source#

readPrec ::ReadPrec (First a)Source#

readListPrec ::ReadPrec [First a]Source#

Methods

showsPrec ::Int ->First a ->ShowSSource#

show ::First a ->StringSource#

showList :: [First a] ->ShowSSource#

Associated Types

typeRep (First a) ::Type ->TypeSource#

Methods

from ::First a ->Rep (First a) xSource#

to ::Rep (First a) x ->First aSource#

Methods

(<>) ::First a ->First a ->First aSource#

sconcat ::NonEmpty (First a) ->First aSource#

stimes ::Integral b => b ->First a ->First aSource#

Associated Types

typeRep1First :: k ->TypeSource#

Methods

from1 ::First a ->Rep1First aSource#

to1 ::Rep1First a ->First aSource#

Methods

(>>=) ::Last a -> (a ->Last b) ->Last bSource#

(>>) ::Last a ->Last b ->Last bSource#

return :: a ->Last aSource#

fail ::String ->Last aSource#

Methods

fmap :: (a -> b) ->Last a ->Last bSource#

(<$) :: a ->Last b ->Last aSource#

Methods

mfix :: (a ->Last a) ->Last aSource#

Methods

pure :: a ->Last aSource#

(<*>) ::Last (a -> b) ->Last a ->Last bSource#

liftA2 :: (a -> b -> c) ->Last a ->Last b ->Last cSource#

(*>) ::Last a ->Last b ->Last bSource#

(<*) ::Last a ->Last b ->Last aSource#

Methods

fold ::Monoid m =>Last m -> mSource#

foldMap ::Monoid m => (a -> m) ->Last a -> mSource#

foldr :: (a -> b -> b) -> b ->Last a -> bSource#

foldr' :: (a -> b -> b) -> b ->Last a -> bSource#

foldl :: (b -> a -> b) -> b ->Last a -> bSource#

foldl' :: (b -> a -> b) -> b ->Last a -> bSource#

foldr1 :: (a -> a -> a) ->Last a -> aSource#

foldl1 :: (a -> a -> a) ->Last a -> aSource#

toList ::Last a -> [a]Source#

null ::Last a ->BoolSource#

length ::Last a ->IntSource#

elem ::Eq a => a ->Last a ->BoolSource#

maximum ::Ord a =>Last a -> aSource#

minimum ::Ord a =>Last a -> aSource#

sum ::Num a =>Last a -> aSource#

product ::Num a =>Last a -> aSource#

Methods

traverse ::Applicative f => (a -> f b) ->Last a -> f (Last b)Source#

sequenceA ::Applicative f =>Last (f a) -> f (Last a)Source#

mapM ::Monad m => (a -> m b) ->Last a -> m (Last b)Source#

sequence ::Monad m =>Last (m a) -> m (Last a)Source#

Methods

minBound ::Last aSource#

maxBound ::Last aSource#

Methods

succ ::Last a ->Last aSource#

pred ::Last a ->Last aSource#

toEnum ::Int ->Last aSource#

fromEnum ::Last a ->IntSource#

enumFrom ::Last a -> [Last a]Source#

enumFromThen ::Last a ->Last a -> [Last a]Source#

enumFromTo ::Last a ->Last a -> [Last a]Source#

enumFromThenTo ::Last a ->Last a ->Last a -> [Last a]Source#

Methods

(==) ::Last a ->Last a ->Bool#

(/=) ::Last a ->Last a ->Bool#

Methods

gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Last a -> c (Last a)Source#

gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Last a)Source#

toConstr ::Last a ->ConstrSource#

dataTypeOf ::Last a ->DataTypeSource#

dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Last a))Source#

dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Last a))Source#

gmapT :: (forall b.Data b => b -> b) ->Last a ->Last aSource#

gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Last a -> rSource#

gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Last a -> rSource#

gmapQ :: (forall d.Data d => d -> u) ->Last a -> [u]Source#

gmapQi ::Int -> (forall d.Data d => d -> u) ->Last a -> uSource#

gmapM ::Monad m => (forall d.Data d => d -> m d) ->Last a -> m (Last a)Source#

gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Last a -> m (Last a)Source#

gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Last a -> m (Last a)Source#

Methods

compare ::Last a ->Last a ->Ordering#

(<) ::Last a ->Last a ->Bool#

(<=) ::Last a ->Last a ->Bool#

(>) ::Last a ->Last a ->Bool#

(>=) ::Last a ->Last a ->Bool#

max ::Last a ->Last a ->Last a#

min ::Last a ->Last a ->Last a#

Methods

readsPrec ::Int ->ReadS (Last a)Source#

readList ::ReadS [Last a]Source#

readPrec ::ReadPrec (Last a)Source#

readListPrec ::ReadPrec [Last a]Source#

Methods

showsPrec ::Int ->Last a ->ShowSSource#

show ::Last a ->StringSource#

showList :: [Last a] ->ShowSSource#

Associated Types

typeRep (Last a) ::Type ->TypeSource#

Methods

from ::Last a ->Rep (Last a) xSource#

to ::Rep (Last a) x ->Last aSource#

Methods

(<>) ::Last a ->Last a ->Last aSource#

sconcat ::NonEmpty (Last a) ->Last aSource#

stimes ::Integral b => b ->Last a ->Last aSource#

Associated Types

typeRep1Last :: k ->TypeSource#

Methods

from1 ::Last a ->Rep1Last aSource#

to1 ::Rep1Last a ->Last aSource#

Methods

minBound ::WrappedMonoid mSource#

maxBound ::WrappedMonoid mSource#

Methods

succ ::WrappedMonoid a ->WrappedMonoid aSource#

pred ::WrappedMonoid a ->WrappedMonoid aSource#

toEnum ::Int ->WrappedMonoid aSource#

fromEnum ::WrappedMonoid a ->IntSource#

enumFrom ::WrappedMonoid a -> [WrappedMonoid a]Source#

enumFromThen ::WrappedMonoid a ->WrappedMonoid a -> [WrappedMonoid a]Source#

enumFromTo ::WrappedMonoid a ->WrappedMonoid a -> [WrappedMonoid a]Source#

enumFromThenTo ::WrappedMonoid a ->WrappedMonoid a ->WrappedMonoid a -> [WrappedMonoid a]Source#

Methods

(==) ::WrappedMonoid m ->WrappedMonoid m ->Bool#

(/=) ::WrappedMonoid m ->WrappedMonoid m ->Bool#

Methods

gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->WrappedMonoid m -> c (WrappedMonoid m)Source#

gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (WrappedMonoid m)Source#

toConstr ::WrappedMonoid m ->ConstrSource#

dataTypeOf ::WrappedMonoid m ->DataTypeSource#

dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (WrappedMonoid m))Source#

dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (WrappedMonoid m))Source#

gmapT :: (forall b.Data b => b -> b) ->WrappedMonoid m ->WrappedMonoid mSource#

gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->WrappedMonoid m -> rSource#

gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->WrappedMonoid m -> rSource#

gmapQ :: (forall d.Data d => d -> u) ->WrappedMonoid m -> [u]Source#

gmapQi ::Int -> (forall d.Data d => d -> u) ->WrappedMonoid m -> uSource#

gmapM ::Monad m0 => (forall d.Data d => d -> m0 d) ->WrappedMonoid m -> m0 (WrappedMonoid m)Source#

gmapMp ::MonadPlus m0 => (forall d.Data d => d -> m0 d) ->WrappedMonoid m -> m0 (WrappedMonoid m)Source#

gmapMo ::MonadPlus m0 => (forall d.Data d => d -> m0 d) ->WrappedMonoid m -> m0 (WrappedMonoid m)Source#

Methods

compare ::WrappedMonoid m ->WrappedMonoid m ->Ordering#

(<) ::WrappedMonoid m ->WrappedMonoid m ->Bool#

(<=) ::WrappedMonoid m ->WrappedMonoid m ->Bool#

(>) ::WrappedMonoid m ->WrappedMonoid m ->Bool#

(>=) ::WrappedMonoid m ->WrappedMonoid m ->Bool#

max ::WrappedMonoid m ->WrappedMonoid m ->WrappedMonoid m#

min ::WrappedMonoid m ->WrappedMonoid m ->WrappedMonoid m#

Methods

readsPrec ::Int ->ReadS (WrappedMonoid m)Source#

readList ::ReadS [WrappedMonoid m]Source#

readPrec ::ReadPrec (WrappedMonoid m)Source#

readListPrec ::ReadPrec [WrappedMonoid m]Source#

Methods

showsPrec ::Int ->WrappedMonoid m ->ShowSSource#

show ::WrappedMonoid m ->StringSource#

showList :: [WrappedMonoid m] ->ShowSSource#

Associated Types

typeRep (WrappedMonoid m) ::Type ->TypeSource#

Methods

from ::WrappedMonoid m ->Rep (WrappedMonoid m) xSource#

to ::Rep (WrappedMonoid m) x ->WrappedMonoid mSource#

Methods

(<>) ::WrappedMonoid m ->WrappedMonoid m ->WrappedMonoid mSource#

sconcat ::NonEmpty (WrappedMonoid m) ->WrappedMonoid mSource#

stimes ::Integral b => b ->WrappedMonoid m ->WrappedMonoid mSource#

Methods

mempty ::WrappedMonoid mSource#

mappend ::WrappedMonoid m ->WrappedMonoid m ->WrappedMonoid mSource#

mconcat :: [WrappedMonoid m] ->WrappedMonoid mSource#

Associated Types

typeRep1WrappedMonoid :: k ->TypeSource#

Methods

from1 ::WrappedMonoid a ->Rep1WrappedMonoid aSource#

to1 ::Rep1WrappedMonoid a ->WrappedMonoid aSource#

Methods

(>>=) ::Dual a -> (a ->Dual b) ->Dual bSource#

(>>) ::Dual a ->Dual b ->Dual bSource#

return :: a ->Dual aSource#

fail ::String ->Dual aSource#

Methods

fmap :: (a -> b) ->Dual a ->Dual bSource#

(<$) :: a ->Dual b ->Dual aSource#

Methods

mfix :: (a ->Dual a) ->Dual aSource#

Methods

pure :: a ->Dual aSource#

(<*>) ::Dual (a -> b) ->Dual a ->Dual bSource#

liftA2 :: (a -> b -> c) ->Dual a ->Dual b ->Dual cSource#

(*>) ::Dual a ->Dual b ->Dual bSource#

(<*) ::Dual a ->Dual b ->Dual aSource#

Methods

fold ::Monoid m =>Dual m -> mSource#

foldMap ::Monoid m => (a -> m) ->Dual a -> mSource#

foldr :: (a -> b -> b) -> b ->Dual a -> bSource#

foldr' :: (a -> b -> b) -> b ->Dual a -> bSource#

foldl :: (b -> a -> b) -> b ->Dual a -> bSource#

foldl' :: (b -> a -> b) -> b ->Dual a -> bSource#

foldr1 :: (a -> a -> a) ->Dual a -> aSource#

foldl1 :: (a -> a -> a) ->Dual a -> aSource#

toList ::Dual a -> [a]Source#

null ::Dual a ->BoolSource#

length ::Dual a ->IntSource#

elem ::Eq a => a ->Dual a ->BoolSource#

maximum ::Ord a =>Dual a -> aSource#

minimum ::Ord a =>Dual a -> aSource#

sum ::Num a =>Dual a -> aSource#

product ::Num a =>Dual a -> aSource#

Methods

traverse ::Applicative f => (a -> f b) ->Dual a -> f (Dual b)Source#

sequenceA ::Applicative f =>Dual (f a) -> f (Dual a)Source#

mapM ::Monad m => (a -> m b) ->Dual a -> m (Dual b)Source#

sequence ::Monad m =>Dual (m a) -> m (Dual a)Source#

Methods

mzip ::Dual a ->Dual b ->Dual (a, b)Source#

mzipWith :: (a -> b -> c) ->Dual a ->Dual b ->Dual cSource#

munzip ::Dual (a, b) -> (Dual a,Dual b)Source#

Methods

minBound ::Dual aSource#

maxBound ::Dual aSource#

Methods

(==) ::Dual a ->Dual a ->Bool#

(/=) ::Dual a ->Dual a ->Bool#

Methods

gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Dual a -> c (Dual a)Source#

gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Dual a)Source#

toConstr ::Dual a ->ConstrSource#

dataTypeOf ::Dual a ->DataTypeSource#

dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Dual a))Source#

dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Dual a))Source#

gmapT :: (forall b.Data b => b -> b) ->Dual a ->Dual aSource#

gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Dual a -> rSource#

gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Dual a -> rSource#

gmapQ :: (forall d.Data d => d -> u) ->Dual a -> [u]Source#

gmapQi ::Int -> (forall d.Data d => d -> u) ->Dual a -> uSource#

gmapM ::Monad m => (forall d.Data d => d -> m d) ->Dual a -> m (Dual a)Source#

gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Dual a -> m (Dual a)Source#

gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Dual a -> m (Dual a)Source#

Methods

compare ::Dual a ->Dual a ->Ordering#

(<) ::Dual a ->Dual a ->Bool#

(<=) ::Dual a ->Dual a ->Bool#

(>) ::Dual a ->Dual a ->Bool#

(>=) ::Dual a ->Dual a ->Bool#

max ::Dual a ->Dual a ->Dual a#

min ::Dual a ->Dual a ->Dual a#

Methods

readsPrec ::Int ->ReadS (Dual a)Source#

readList ::ReadS [Dual a]Source#

readPrec ::ReadPrec (Dual a)Source#

readListPrec ::ReadPrec [Dual a]Source#

Methods

showsPrec ::Int ->Dual a ->ShowSSource#

show ::Dual a ->StringSource#

showList :: [Dual a] ->ShowSSource#

Associated Types

typeRep (Dual a) ::Type ->TypeSource#

Methods

from ::Dual a ->Rep (Dual a) xSource#

to ::Rep (Dual a) x ->Dual aSource#

Methods

(<>) ::Dual a ->Dual a ->Dual aSource#

sconcat ::NonEmpty (Dual a) ->Dual aSource#

stimes ::Integral b => b ->Dual a ->Dual aSource#

Methods

mempty ::Dual aSource#

mappend ::Dual a ->Dual a ->Dual aSource#

mconcat :: [Dual a] ->Dual aSource#

Associated Types

typeRep1Dual :: k ->TypeSource#

Methods

from1 ::Dual a ->Rep1Dual aSource#

to1 ::Rep1Dual a ->Dual aSource#

Associated Types

typeRep (Endo a) ::Type ->TypeSource#

Methods

from ::Endo a ->Rep (Endo a) xSource#

to ::Rep (Endo a) x ->Endo aSource#

Methods

(<>) ::Endo a ->Endo a ->Endo aSource#

sconcat ::NonEmpty (Endo a) ->Endo aSource#