Safe Haskell | Safe |
---|---|
Language | Haskell98 |
Lens.Family
Description
This is the main module for end-users of lens-families-core. If you are not building your own lenses or traversals, but just using functional references made by others, this is the only module you need.
Synopsis
- to :: Phantom f => (a -> b) -> LensLike f a a' b b'
- view :: FoldLike b a a' b b' -> a -> b
- (^.) :: a -> FoldLike b a a' b b' -> b
- folding :: (Foldable g, Phantom f, Applicative f) => (a -> g b) -> LensLike f a a' b b'
- views :: FoldLike r a a' b b' -> (b -> r) -> a -> r
- (^..) :: a -> FoldLike [b] a a' b b' -> [b]
- (^?) :: a -> FoldLike (First b) a a' b b' -> Maybe b
- toListOf :: FoldLike [b] a a' b b' -> a -> [b]
- allOf :: FoldLike All a a' b b' -> (b -> Bool) -> a -> Bool
- anyOf :: FoldLike Any a a' b b' -> (b -> Bool) -> a -> Bool
- firstOf :: FoldLike (First b) a a' b b' -> a -> Maybe b
- lastOf :: FoldLike (Last b) a a' b b' -> a -> Maybe b
- sumOf :: Num b => FoldLike (Sum b) a a' b b' -> a -> b
- productOf :: Num b => FoldLike (Product b) a a' b b' -> a -> b
- lengthOf :: Num r => FoldLike (Sum r) a a' b b' -> a -> r
- nullOf :: FoldLike All a a' b b' -> a -> Bool
- backwards :: LensLike (Backwards f) a a' b b' -> LensLike f a a' b b'
- over :: ASetter a a' b b' -> (b -> b') -> a -> a'
- (%~) :: ASetter a a' b b' -> (b -> b') -> a -> a'
- set :: ASetter a a' b b' -> b' -> a -> a'
- (.~) :: ASetter a a' b b' -> b' -> a -> a'
- (&) :: a -> (a -> b) -> b
- (+~) :: Num b => ASetter' a b -> b -> a -> a
- (*~) :: Num b => ASetter' a b -> b -> a -> a
- (-~) :: Num b => ASetter' a b -> b -> a -> a
- (//~) :: Fractional b => ASetter' a b -> b -> a -> a
- (&&~) :: ASetter' a Bool -> Bool -> a -> a
- (||~) :: ASetter' a Bool -> Bool -> a -> a
- (<>~) :: Monoid o => ASetter' a o -> o -> a -> a
- type LensLike f a a' b b' = (b -> f b') -> a -> f a'
- type LensLike' f a b = (b -> f b) -> a -> f a
- type FoldLike r a a' b b' = LensLike (Constant r) a a' b b'
- type FoldLike' r a b = LensLike' (Constant r) a b
- type ASetter a a' b b' = LensLike Identity a a' b b'
- type ASetter' a b = LensLike' Identity a b
- class Functor f => Phantom f
- data Constant a (b :: k) :: forall k. Type -> k -> Type
- data Identity a
- class Functor f => Applicative (f :: Type -> Type)
- class Foldable (t :: Type -> Type)
- class Semigroup a => Monoid a
- data Backwards (f :: k -> Type) (a :: k) :: forall k. (k -> Type) -> k -> Type
- data All
- data Any
- data First a
- data Last a
- data Sum a
- data Product a
Lenses
This module provides ^.
for accessing fields and .~
and %~
for setting and modifying fields.
Lenses are composed with .
from the Prelude
and id
is the identity lens.
Lens composition in this library enjoys the following identities.
x^.l1.l2 === x^.l1^.l2
l1.l2 %~ f === l1 %~ l2 %~ f
The identity lens behaves as follows.
x^.id === x
id %~ f === f
The &
operator, allows for a convenient way to sequence record updating:
record & l1 .~ value1 & l2 .~ value2
Lenses are implemented in van Laarhoven style.
Lenses have type
and lens families have type Functor
f => (b -> f b) -> a -> f a
.Functor
f => (b i -> f (b j)) -> a i -> f (a j)
Keep in mind that lenses and lens families can be used directly for functorial updates.
For example, _2 id
gives you strength.
_2 id :: Functor f => (a, f b) -> f (a, b)
Here is an example of code that uses the Maybe
functor to preserves sharing during update when possible.
-- | 'sharedUpdate' returns the *identical* object if the update doesn't change anything. -- This is useful for preserving sharing. sharedUpdate :: Eq b => LensLike' Maybe a b -> (b -> b) -> a -> a sharedUpdate l f a = fromMaybe a (l f' a) where f' b | fb == b = Nothing | otherwise = Just fb where fb = f b
Traversals
^.
can be used with traversals to access monoidal fields.
The result will be a mconcat
of all the fields referenced.
The various fooOf
functions can be used to access different monoidal summaries of some kinds of values.
^?
can be used to access the first value of a traversal.
Nothing
is returned when the traversal has no references.
^..
can be used with a traversals and will return a list of all fields referenced.
When .~
is used with a traversal, all referenced fields will be set to the same value, and when %~
is used with a traversal, all referenced fields will be modified with the same function.
Like lenses, traversals can be composed with .
, and because every lens is automatically a traversal, lenses and traversals can be composed with .
yielding a traversal.
Traversals are implemented in van Laarhoven style.
Traversals have type
and traversal families have type Applicative
f => (b -> f b) -> a -> f a
.Applicative
f => (b i -> f (b j)) -> a i -> f (a j)
For stock lenses and traversals, see Lens.Family.Stock.
To build your own lenses and traversals, see Lens.Family.Unchecked.
References:
Documentation
to :: Phantom f => (a -> b) -> LensLike f a a' b b' Source #
to :: (a -> b) -> Getter a a' b b'
to
promotes a projection function to a read-only lens called a getter.
To demote a lens to a projection function, use the section (^.l)
or view l
.
>>>
(3 :+ 4, "example")^._1.to(abs)
5.0 :+ 0.0
view :: FoldLike b a a' b b' -> a -> b Source #
view :: Getter a a' b b' -> a -> b
Demote a lens or getter to a projection function.
view :: Monoid b => Fold a a' b b' -> a -> b
Returns the monoidal summary of a traversal or a fold.
(^.) :: a -> FoldLike b a a' b b' -> b infixl 8 Source #
(^.) :: a -> Getter a a' b b' -> b
Access the value referenced by a getter or lens.
(^.) :: Monoid b => a -> Fold a a' b b' -> b
Access the monoidal summary referenced by a getter or lens.
folding :: (Foldable g, Phantom f, Applicative f) => (a -> g b) -> LensLike f a a' b b' Source #
folding :: (a -> [b]) -> Fold a a' b b'
folding
promotes a "toList" function to a read-only traversal called a fold.
To demote a traversal or fold to a "toList" function use the section (^..l)
or toListOf l
.
views :: FoldLike r a a' b b' -> (b -> r) -> a -> r Source #
views :: Monoid r => Fold a a' b b' -> (b -> r) -> a -> r
Given a fold or traversal, return the foldMap
of all the values using the given function.
views :: Getter a a' b b' -> (b -> r) -> a -> r
views
is not particularly useful for getters or lenses, but given a getter or lens, it returns the referenced value passed through the given function.
views l f a = f (view l a)
(^..) :: a -> FoldLike [b] a a' b b' -> [b] infixl 8 Source #
(^..) :: a -> Getter a a' b b' -> [b]
Returns a list of all of the referenced values in order.
(^?) :: a -> FoldLike (First b) a a' b b' -> Maybe b infixl 8 Source #
(^?) :: a -> Fold a a' b b' -> Maybe b
Returns Just
the first referenced value.
Returns Nothing
if there are no referenced values.
toListOf :: FoldLike [b] a a' b b' -> a -> [b] Source #
toListOf :: Fold a a' b b' -> a -> [b]
Returns a list of all of the referenced values in order.
allOf :: FoldLike All a a' b b' -> (b -> Bool) -> a -> Bool Source #
allOf :: Fold a a' b b' -> (b -> Bool) -> a -> Bool
Returns true if all of the referenced values satisfy the given predicate.
anyOf :: FoldLike Any a a' b b' -> (b -> Bool) -> a -> Bool Source #
anyOf :: Fold a a' b b' -> (b -> Bool) -> a -> Bool
Returns true if any of the referenced values satisfy the given predicate.
lastOf :: FoldLike (Last b) a a' b b' -> a -> Maybe b Source #
lastOf :: Fold a a' b b' -> a -> Maybe b
Returns Just
the last referenced value.
Returns Nothing
if there are no referenced values.
sumOf :: Num b => FoldLike (Sum b) a a' b b' -> a -> b Source #
sumOf :: Num b => Fold a a' b b' -> a -> b
Returns the sum of all the referenced values.
productOf :: Num b => FoldLike (Product b) a a' b b' -> a -> b Source #
productOf :: Num b => Fold a a' b b' -> a -> b
Returns the product of all the referenced values.
lengthOf :: Num r => FoldLike (Sum r) a a' b b' -> a -> r Source #
lengthOf :: Num r => Fold a a' b b' -> a -> r
Counts the number of references in a traversal or fold for the input.
nullOf :: FoldLike All a a' b b' -> a -> Bool Source #
nullOf :: Fold a a' b b' -> a -> Bool
Returns true if the number of references in the input is zero.
backwards :: LensLike (Backwards f) a a' b b' -> LensLike f a a' b b' Source #
backwards :: Traversal a a' b b' -> Traversal a a' b b' backwards :: Fold a a' b b' -> Fold a a' b b'
Given a traversal or fold, reverse the order that elements are traversed.
backwards :: Lens a a' b b' -> Lens a a' b b' backwards :: Getter a a' b b' -> Getter a a' b b' backwards :: Setter a a' b b' -> Setter a a' b b'
No effect on lenses, getters or setters.
over :: ASetter a a' b b' -> (b -> b') -> a -> a' Source #
Demote a setter to a semantic editor combinator.
(.~) :: ASetter a a' b b' -> b' -> a -> a' infixr 4 Source #
Set all referenced fields to the given value.
Pseudo-imperatives
(<>~) :: Monoid o => ASetter' a o -> o -> a -> a infixr 4 Source #
Monoidally append a value to all referenced fields.
Types
class Functor f => Phantom f Source #
Minimal complete definition
coerce
Instances
Phantom f => Phantom (Backwards f) Source # | |
Defined in Lens.Family.Phantom | |
Phantom (Const a :: Type -> Type) Source # | |
Defined in Lens.Family.Phantom Methods coerce :: Const a a0 -> Const a b | |
Phantom (Constant a :: Type -> Type) Source # | |
Defined in Lens.Family.Phantom | |
Phantom f => Phantom (AlongsideRight f a) Source # | |
Defined in Lens.Family.Stock Methods coerce :: AlongsideRight f a a0 -> AlongsideRight f a b | |
Phantom f => Phantom (AlongsideLeft f a) Source # | |
Defined in Lens.Family.Stock Methods coerce :: AlongsideLeft f a a0 -> AlongsideLeft f a b | |
(Phantom f, Functor g) => Phantom (Compose f g) Source # | |
Defined in Lens.Family.Phantom Methods coerce :: Compose f g a -> Compose f g b |
data Constant a (b :: k) :: forall k. Type -> k -> Type #
Instances
Bifoldable (Constant :: Type -> Type -> Type) | |
Bifunctor (Constant :: Type -> Type -> Type) | |
Bitraversable (Constant :: Type -> Type -> Type) | |
Defined in Data.Functor.Constant Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Constant a b -> f (Constant c d) | |
Eq2 (Constant :: Type -> Type -> Type) | |
Defined in Data.Functor.Constant | |
Ord2 (Constant :: Type -> Type -> Type) | |
Defined in Data.Functor.Constant Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Constant a c -> Constant b d -> Ordering | |
Read2 (Constant :: Type -> Type -> Type) | |
Defined in Data.Functor.Constant Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Constant a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Constant a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Constant a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Constant a b] | |
Show2 (Constant :: Type -> Type -> Type) | |
Defined in Data.Functor.Constant Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Constant a b -> ShowS liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Constant a b] -> ShowS | |
Functor (Constant a :: Type -> Type) | |
Monoid a => Applicative (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant | |
Foldable (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant Methods fold :: Monoid m => Constant a m -> m foldMap :: Monoid m => (a0 -> m) -> Constant a a0 -> m foldr :: (a0 -> b -> b) -> b -> Constant a a0 -> b foldr' :: (a0 -> b -> b) -> b -> Constant a a0 -> b foldl :: (b -> a0 -> b) -> b -> Constant a a0 -> b foldl' :: (b -> a0 -> b) -> b -> Constant a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0 foldl1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0 toList :: Constant a a0 -> [a0] length :: Constant a a0 -> Int elem :: Eq a0 => a0 -> Constant a a0 -> Bool maximum :: Ord a0 => Constant a a0 -> a0 minimum :: Ord a0 => Constant a a0 -> a0 | |
Traversable (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant | |
Contravariant (Constant a :: Type -> Type) | |
Eq a => Eq1 (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant | |
Ord a => Ord1 (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant Methods liftCompare :: (a0 -> b -> Ordering) -> Constant a a0 -> Constant a b -> Ordering | |
Read a => Read1 (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Constant a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Constant a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Constant a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Constant a a0] | |
Show a => Show1 (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Constant a a0 -> ShowS liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Constant a a0] -> ShowS | |
Phantom (Constant a :: Type -> Type) Source # | |
Defined in Lens.Family.Phantom | |
Eq a => Eq (Constant a b) | |
Ord a => Ord (Constant a b) | |
Defined in Data.Functor.Constant | |
Read a => Read (Constant a b) | |
Defined in Data.Functor.Constant | |
Show a => Show (Constant a b) | |
Semigroup a => Semigroup (Constant a b) | |
Monoid a => Monoid (Constant a b) | |
Instances
Monad Identity | |
Functor Identity | |
MonadFix Identity | |
Defined in Data.Functor.Identity | |
Applicative Identity | |
Foldable Identity | |
Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m foldMap :: Monoid m => (a -> m) -> Identity a -> m foldr :: (a -> b -> b) -> b -> Identity a -> b foldr' :: (a -> b -> b) -> b -> Identity a -> b foldl :: (b -> a -> b) -> b -> Identity a -> b foldl' :: (b -> a -> b) -> b -> Identity a -> b foldr1 :: (a -> a -> a) -> Identity a -> a foldl1 :: (a -> a -> a) -> Identity a -> a elem :: Eq a => a -> Identity a -> Bool maximum :: Ord a => Identity a -> a minimum :: Ord a => Identity a -> a | |
Traversable Identity | |
Defined in Data.Traversable | |
Eq1 Identity | |
Defined in Data.Functor.Classes | |
Ord1 Identity | |
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Identity a -> Identity b -> Ordering | |
Read1 Identity | |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Identity a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Identity a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Identity a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Identity a] | |
Show1 Identity | |
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS | |
Identical Identity Source # | |
Defined in Lens.Family.Identical | |
Bounded a => Bounded (Identity a) | |
Defined in Data.Functor.Identity | |
Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity | |
Eq a => Eq (Identity a) | |
Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity Methods exp :: Identity a -> Identity a log :: Identity a -> Identity a sqrt :: Identity a -> Identity a (**) :: Identity a -> Identity a -> Identity a logBase :: Identity a -> Identity a -> Identity a sin :: Identity a -> Identity a cos :: Identity a -> Identity a tan :: Identity a -> Identity a asin :: Identity a -> Identity a acos :: Identity a -> Identity a atan :: Identity a -> Identity a sinh :: Identity a -> Identity a cosh :: Identity a -> Identity a tanh :: Identity a -> Identity a asinh :: Identity a -> Identity a acosh :: Identity a -> Identity a atanh :: Identity a -> Identity a log1p :: Identity a -> Identity a expm1 :: Identity a -> Identity a | |
Fractional a => Fractional (Identity a) | |
Defined in Data.Functor.Identity | |
Integral a => Integral (Identity a) | |
Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a rem :: Identity a -> Identity a -> Identity a div :: Identity a -> Identity a -> Identity a mod :: Identity a -> Identity a -> Identity a quotRem :: Identity a -> Identity a -> (Identity a, Identity a) divMod :: Identity a -> Identity a -> (Identity a, Identity a) | |
Num a => Num (Identity a) | |
Defined in Data.Functor.Identity | |
Ord a => Ord (Identity a) | |
Read a => Read (Identity a) | |
Defined in Data.Functor.Identity | |
Real a => Real (Identity a) | |
Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational | |
RealFloat a => RealFloat (Identity a) | |
Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer floatDigits :: Identity a -> Int floatRange :: Identity a -> (Int, Int) decodeFloat :: Identity a -> (Integer, Int) encodeFloat :: Integer -> Int -> Identity a significand :: Identity a -> Identity a scaleFloat :: Int -> Identity a -> Identity a isInfinite :: Identity a -> Bool isDenormalized :: Identity a -> Bool isNegativeZero :: Identity a -> Bool | |
RealFrac a => RealFrac (Identity a) | |
Show a => Show (Identity a) | |
Ix a => Ix (Identity a) | |
Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] index :: (Identity a, Identity a) -> Identity a -> Int unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int inRange :: (Identity a, Identity a) -> Identity a -> Bool rangeSize :: (Identity a, Identity a) -> Int unsafeRangeSize :: (Identity a, Identity a) -> Int | |
Generic (Identity a) | |
Semigroup a => Semigroup (Identity a) | |
Monoid a => Monoid (Identity a) | |
Bits a => Bits (Identity a) | |
Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a (.|.) :: Identity a -> Identity a -> Identity a xor :: Identity a -> Identity a -> Identity a complement :: Identity a -> Identity a shift :: Identity a -> Int -> Identity a rotate :: Identity a -> Int -> Identity a setBit :: Identity a -> Int -> Identity a clearBit :: Identity a -> Int -> Identity a complementBit :: Identity a -> Int -> Identity a testBit :: Identity a -> Int -> Bool bitSizeMaybe :: Identity a -> Maybe Int isSigned :: Identity a -> Bool shiftL :: Identity a -> Int -> Identity a unsafeShiftL :: Identity a -> Int -> Identity a shiftR :: Identity a -> Int -> Identity a unsafeShiftR :: Identity a -> Int -> Identity a rotateL :: Identity a -> Int -> Identity a | |
FiniteBits a => FiniteBits (Identity a) | |
Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int countLeadingZeros :: Identity a -> Int countTrailingZeros :: Identity a -> Int | |
Storable a => Storable (Identity a) | |
Defined in Data.Functor.Identity Methods alignment :: Identity a -> Int peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () peekByteOff :: Ptr b -> Int -> IO (Identity a) pokeByteOff :: Ptr b -> Int -> Identity a -> IO () | |
Generic1 Identity | |
type Rep (Identity a) | |
Defined in Data.Functor.Identity type Rep (Identity a) = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) | |
type Rep1 Identity | |
Defined in Data.Functor.Identity type Rep1 Identity = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)) |
Re-exports
class Functor f => Applicative (f :: Type -> Type) #
Minimal complete definition
pure, ((<*>) | liftA2)
Instances
Applicative [] | |
Applicative Maybe | |
Applicative IO | |
Applicative Par1 | |
Applicative Product | |
Applicative Sum | |
Applicative P | |
Applicative Identity | |
Applicative NonEmpty | |
Applicative Dual | |
Applicative ZipList | |
Applicative ReadP | |
Applicative First | |
Applicative Last | |
Applicative Down | |
Applicative (Either e) | |
Applicative (U1 :: Type -> Type) | |
Monoid a => Applicative ((,) a) | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a | |
Arrow a => Applicative (ArrowMonad a) | |
Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 | |
Applicative (Proxy :: Type -> Type) | |
Applicative f => Applicative (Rec1 f) | |
Applicative f => Applicative (Backwards f) | |
Defined in Control.Applicative.Backwards | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Monoid a => Applicative (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant | |
Applicative f => Applicative (Ap f) | |
Applicative f => Applicative (Alt f) | |
(Monoid c, Monad m) => Applicative (Zooming m c) Source # | |
Defined in Lens.Family.State.Zoom | |
(Applicative f, Monad f) => Applicative (WhenMissing f x) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
Applicative (IKleeneStore b b') Source # | |
Defined in Lens.Family.Clone Methods pure :: a -> IKleeneStore b b' a (<*>) :: IKleeneStore b b' (a -> b0) -> IKleeneStore b b' a -> IKleeneStore b b' b0 liftA2 :: (a -> b0 -> c) -> IKleeneStore b b' a -> IKleeneStore b b' b0 -> IKleeneStore b b' c (*>) :: IKleeneStore b b' a -> IKleeneStore b b' b0 -> IKleeneStore b b' b0 (<*) :: IKleeneStore b b' a -> IKleeneStore b b' b0 -> IKleeneStore b b' a | |
Applicative ((->) a :: Type -> Type) | |
Monoid c => Applicative (K1 i c :: Type -> Type) | |
(Applicative f, Applicative g) => Applicative (f :*: g) | |
(Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a | |
(Monad f, Applicative f) => Applicative (WhenMatched f x y) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a | |
Applicative f => Applicative (M1 i c f) | |
(Applicative f, Applicative g) => Applicative (f :.: g) | |
(Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
(Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a |
class Foldable (t :: Type -> Type) #
Minimal complete definition
foldMap | foldr
Instances
Foldable [] | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> [a] -> m foldr :: (a -> b -> b) -> b -> [a] -> b foldr' :: (a -> b -> b) -> b -> [a] -> b foldl :: (b -> a -> b) -> b -> [a] -> b foldl' :: (b -> a -> b) -> b -> [a] -> b foldr1 :: (a -> a -> a) -> [a] -> a foldl1 :: (a -> a -> a) -> [a] -> a toList :: [a] -> [a] null :: [a] -> Bool length :: [a] -> Int elem :: Eq a => a -> [a] -> Bool maximum :: Ord a => [a] -> a minimum :: Ord a => [a] -> a sum :: Num a => [a] -> a product :: Num a => [a] -> a | |
Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a foldl1 :: (a -> a -> a) -> Maybe a -> a toList :: Maybe a -> [a] null :: Maybe a -> Bool length :: Maybe a -> Int elem :: Eq a => a -> Maybe a -> Bool maximum :: Ord a => Maybe a -> a minimum :: Ord a => Maybe a -> a sum :: Num a => Maybe a -> a product :: Num a => Maybe a -> a | |
Foldable Par1 | |
Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m foldMap :: Monoid m => (a -> m) -> Par1 a -> m foldr :: (a -> b -> b) -> b -> Par1 a -> b foldr' :: (a -> b -> b) -> b -> Par1 a -> b foldl :: (b -> a -> b) -> b -> Par1 a -> b foldl' :: (b -> a -> b) -> b -> Par1 a -> b foldr1 :: (a -> a -> a) -> Par1 a -> a foldl1 :: (a -> a -> a) -> Par1 a -> a toList :: Par1 a -> [a] null :: Par1 a -> Bool length :: Par1 a -> Int elem :: Eq a => a -> Par1 a -> Bool maximum :: Ord a => Par1 a -> a minimum :: Ord a => Par1 a -> a sum :: Num a => Par1 a -> a product :: Num a => Par1 a -> a | |
Foldable Product | |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m foldr :: (a -> b -> b) -> b -> Product a -> b foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b foldl' :: (b -> a -> b) -> b -> Product a -> b foldr1 :: (a -> a -> a) -> Product a -> a foldl1 :: (a -> a -> a) -> Product a -> a elem :: Eq a => a -> Product a -> Bool maximum :: Ord a => Product a -> a minimum :: Ord a => Product a -> a | |
Foldable Sum | |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m foldr :: (a -> b -> b) -> b -> Sum a -> b foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b foldl' :: (b -> a -> b) -> b -> Sum a -> b foldr1 :: (a -> a -> a) -> Sum a -> a foldl1 :: (a -> a -> a) -> Sum a -> a elem :: Eq a => a -> Sum a -> Bool maximum :: Ord a => Sum a -> a | |
Foldable Identity | |
Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m foldMap :: Monoid m => (a -> m) -> Identity a -> m foldr :: (a -> b -> b) -> b -> Identity a -> b foldr' :: (a -> b -> b) -> b -> Identity a -> b foldl :: (b -> a -> b) -> b -> Identity a -> b foldl' :: (b -> a -> b) -> b -> Identity a -> b foldr1 :: (a -> a -> a) -> Identity a -> a foldl1 :: (a -> a -> a) -> Identity a -> a elem :: Eq a => a -> Identity a -> Bool maximum :: Ord a => Identity a -> a minimum :: Ord a => Identity a -> a | |
Foldable NonEmpty | |
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m foldr :: (a -> b -> b) -> b -> NonEmpty a -> b foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b foldl :: (b -> a -> b) -> b -> NonEmpty a -> b foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b foldr1 :: (a -> a -> a) -> NonEmpty a -> a foldl1 :: (a -> a -> a) -> NonEmpty a -> a toList :: NonEmpty a -> [a] null :: NonEmpty a -> Bool length :: NonEmpty a -> Int elem :: Eq a => a -> NonEmpty a -> Bool maximum :: Ord a => NonEmpty a -> a minimum :: Ord a => NonEmpty a -> a sum :: Num a => NonEmpty a -> a product :: Num a => NonEmpty a -> a | |
Foldable Dual | |
Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m foldMap :: Monoid m => (a -> m) -> Dual a -> m foldr :: (a -> b -> b) -> b -> Dual a -> b foldr' :: (a -> b -> b) -> b -> Dual a -> b foldl :: (b -> a -> b) -> b -> Dual a -> b foldl' :: (b -> a -> b) -> b -> Dual a -> b foldr1 :: (a -> a -> a) -> Dual a -> a foldl1 :: (a -> a -> a) -> Dual a -> a toList :: Dual a -> [a] null :: Dual a -> Bool length :: Dual a -> Int elem :: Eq a => a -> Dual a -> Bool maximum :: Ord a => Dual a -> a minimum :: Ord a => Dual a -> a sum :: Num a => Dual a -> a product :: Num a => Dual a -> a | |
Foldable ZipList | |
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m foldr :: (a -> b -> b) -> b -> ZipList a -> b foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b foldl' :: (b -> a -> b) -> b -> ZipList a -> b foldr1 :: (a -> a -> a) -> ZipList a -> a foldl1 :: (a -> a -> a) -> ZipList a -> a toList :: ZipList a -> [a] null :: ZipList a -> Bool length :: ZipList a -> Int elem :: Eq a => a -> ZipList a -> Bool maximum :: Ord a => ZipList a -> a minimum :: Ord a => ZipList a -> a sum :: Num a => ZipList a -> a product :: Num a => ZipList a -> a | |
Foldable First | |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a foldl1 :: (a -> a -> a) -> First a -> a elem :: Eq a => a -> First a -> Bool maximum :: Ord a => First a -> a | |
Foldable Last | |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a foldl1 :: (a -> a -> a) -> Last a -> a elem :: Eq a => a -> Last a -> Bool maximum :: Ord a => Last a -> a | |
Foldable Down | |
Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m foldMap :: Monoid m => (a -> m) -> Down a -> m foldr :: (a -> b -> b) -> b -> Down a -> b foldr' :: (a -> b -> b) -> b -> Down a -> b foldl :: (b -> a -> b) -> b -> Down a -> b foldl' :: (b -> a -> b) -> b -> Down a -> b foldr1 :: (a -> a -> a) -> Down a -> a foldl1 :: (a -> a -> a) -> Down a -> a toList :: Down a -> [a] null :: Down a -> Bool length :: Down a -> Int elem :: Eq a => a -> Down a -> Bool maximum :: Ord a => Down a -> a minimum :: Ord a => Down a -> a sum :: Num a => Down a -> a product :: Num a => Down a -> a | |
Foldable IntMap | |
Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m foldMap :: Monoid m => (a -> m) -> IntMap a -> m foldr :: (a -> b -> b) -> b -> IntMap a -> b foldr' :: (a -> b -> b) -> b -> IntMap a -> b foldl :: (b -> a -> b) -> b -> IntMap a -> b foldl' :: (b -> a -> b) -> b -> IntMap a -> b foldr1 :: (a -> a -> a) -> IntMap a -> a foldl1 :: (a -> a -> a) -> IntMap a -> a toList :: IntMap a -> [a] null :: IntMap a -> Bool length :: IntMap a -> Int elem :: Eq a => a -> IntMap a -> Bool maximum :: Ord a => IntMap a -> a minimum :: Ord a => IntMap a -> a sum :: Num a => IntMap a -> a product :: Num a => IntMap a -> a | |
Foldable Set | |
Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m foldMap :: Monoid m => (a -> m) -> Set a -> m foldr :: (a -> b -> b) -> b -> Set a -> b foldr' :: (a -> b -> b) -> b -> Set a -> b foldl :: (b -> a -> b) -> b -> Set a -> b foldl' :: (b -> a -> b) -> b -> Set a -> b foldr1 :: (a -> a -> a) -> Set a -> a foldl1 :: (a -> a -> a) -> Set a -> a toList :: Set a -> [a] null :: Set a -> Bool length :: Set a -> Int elem :: Eq a => a -> Set a -> Bool maximum :: Ord a => Set a -> a minimum :: Ord a => Set a -> a sum :: Num a => Set a -> a product :: Num a => Set a -> a | |
Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 toList :: Either a a0 -> [a0] null :: Either a a0 -> Bool length :: Either a a0 -> Int elem :: Eq a0 => a0 -> Either a a0 -> Bool maximum :: Ord a0 => Either a a0 -> a0 minimum :: Ord a0 => Either a a0 -> a0 sum :: Num a0 => Either a a0 -> a0 product :: Num a0 => Either a a0 -> a0 | |
Foldable (V1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> V1 a -> m foldr :: (a -> b -> b) -> b -> V1 a -> b foldr' :: (a -> b -> b) -> b -> V1 a -> b foldl :: (b -> a -> b) -> b -> V1 a -> b foldl' :: (b -> a -> b) -> b -> V1 a -> b foldr1 :: (a -> a -> a) -> V1 a -> a foldl1 :: (a -> a -> a) -> V1 a -> a toList :: V1 a -> [a] null :: V1 a -> Bool length :: V1 a -> Int elem :: Eq a => a -> V1 a -> Bool maximum :: Ord a => V1 a -> a minimum :: Ord a => V1 a -> a sum :: Num a => V1 a -> a product :: Num a => V1 a -> a | |
Foldable (U1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> U1 a -> m foldr :: (a -> b -> b) -> b -> U1 a -> b foldr' :: (a -> b -> b) -> b -> U1 a -> b foldl :: (b -> a -> b) -> b -> U1 a -> b foldl' :: (b -> a -> b) -> b -> U1 a -> b foldr1 :: (a -> a -> a) -> U1 a -> a foldl1 :: (a -> a -> a) -> U1 a -> a toList :: U1 a -> [a] null :: U1 a -> Bool length :: U1 a -> Int elem :: Eq a => a -> U1 a -> Bool maximum :: Ord a => U1 a -> a minimum :: Ord a => U1 a -> a sum :: Num a => U1 a -> a product :: Num a => U1 a -> a | |
Foldable ((,) a) | |
Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 toList :: (a, a0) -> [a0] null :: (a, a0) -> Bool length :: (a, a0) -> Int elem :: Eq a0 => a0 -> (a, a0) -> Bool maximum :: Ord a0 => (a, a0) -> a0 minimum :: Ord a0 => (a, a0) -> a0 sum :: Num a0 => (a, a0) -> a0 product :: Num a0 => (a, a0) -> a0 | |
Foldable (Array i) | |
Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m foldMap :: Monoid m => (a -> m) -> Array i a -> m foldr :: (a -> b -> b) -> b -> Array i a -> b foldr' :: (a -> b -> b) -> b -> Array i a -> b foldl :: (b -> a -> b) -> b -> Array i a -> b foldl' :: (b -> a -> b) -> b -> Array i a -> b foldr1 :: (a -> a -> a) -> Array i a -> a foldl1 :: (a -> a -> a) -> Array i a -> a toList :: Array i a -> [a] null :: Array i a -> Bool length :: Array i a -> Int elem :: Eq a => a -> Array i a -> Bool maximum :: Ord a => Array i a -> a minimum :: Ord a => Array i a -> a sum :: Num a => Array i a -> a product :: Num a => Array i a -> a | |
Foldable (Proxy :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m foldMap :: Monoid m => (a -> m) -> Proxy a -> m foldr :: (a -> b -> b) -> b -> Proxy a -> b foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b foldl' :: (b -> a -> b) -> b -> Proxy a -> b foldr1 :: (a -> a -> a) -> Proxy a -> a foldl1 :: (a -> a -> a) -> Proxy a -> a toList :: Proxy a -> [a] null :: Proxy a -> Bool length :: Proxy a -> Int elem :: Eq a => a -> Proxy a -> Bool maximum :: Ord a => Proxy a -> a minimum :: Ord a => Proxy a -> a sum :: Num a => Proxy a -> a product :: Num a => Proxy a -> a | |
Foldable (Map k) | |
Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m foldMap :: Monoid m => (a -> m) -> Map k a -> m foldr :: (a -> b -> b) -> b -> Map k a -> b foldr' :: (a -> b -> b) -> b -> Map k a -> b foldl :: (b -> a -> b) -> b -> Map k a -> b foldl' :: (b -> a -> b) -> b -> Map k a -> b foldr1 :: (a -> a -> a) -> Map k a -> a foldl1 :: (a -> a -> a) -> Map k a -> a toList :: Map k a -> [a] null :: Map k a -> Bool length :: Map k a -> Int elem :: Eq a => a -> Map k a -> Bool maximum :: Ord a => Map k a -> a minimum :: Ord a => Map k a -> a sum :: Num a => Map k a -> a product :: Num a => Map k a -> a | |
Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m foldr :: (a -> b -> b) -> b -> Rec1 f a -> b foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b foldl :: (b -> a -> b) -> b -> Rec1 f a -> b foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b foldr1 :: (a -> a -> a) -> Rec1 f a -> a foldl1 :: (a -> a -> a) -> Rec1 f a -> a toList :: Rec1 f a -> [a] null :: Rec1 f a -> Bool length :: Rec1 f a -> Int elem :: Eq a => a -> Rec1 f a -> Bool maximum :: Ord a => Rec1 f a -> a minimum :: Ord a => Rec1 f a -> a sum :: Num a => Rec1 f a -> a product :: Num a => Rec1 f a -> a | |
Foldable (URec Char :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Char m -> m foldMap :: Monoid m => (a -> m) -> URec Char a -> m foldr :: (a -> b -> b) -> b -> URec Char a -> b foldr' :: (a -> b -> b) -> b -> URec Char a -> b foldl :: (b -> a -> b) -> b -> URec Char a -> b foldl' :: (b -> a -> b) -> b -> URec Char a -> b foldr1 :: (a -> a -> a) -> URec Char a -> a foldl1 :: (a -> a -> a) -> URec Char a -> a toList :: URec Char a -> [a] null :: URec Char a -> Bool length :: URec Char a -> Int elem :: Eq a => a -> URec Char a -> Bool maximum :: Ord a => URec Char a -> a minimum :: Ord a => URec Char a -> a sum :: Num a => URec Char a -> a product :: Num a => URec Char a -> a | |
Foldable (URec Double :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Double m -> m foldMap :: Monoid m => (a -> m) -> URec Double a -> m foldr :: (a -> b -> b) -> b -> URec Double a -> b foldr' :: (a -> b -> b) -> b -> URec Double a -> b foldl :: (b -> a -> b) -> b -> URec Double a -> b foldl' :: (b -> a -> b) -> b -> URec Double a -> b foldr1 :: (a -> a -> a) -> URec Double a -> a foldl1 :: (a -> a -> a) -> URec Double a -> a toList :: URec Double a -> [a] null :: URec Double a -> Bool length :: URec Double a -> Int elem :: Eq a => a -> URec Double a -> Bool maximum :: Ord a => URec Double a -> a minimum :: Ord a => URec Double a -> a sum :: Num a => URec Double a -> a product :: Num a => URec Double a -> a | |
Foldable (URec Float :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Float m -> m foldMap :: Monoid m => (a -> m) -> URec Float a -> m foldr :: (a -> b -> b) -> b -> URec Float a -> b foldr' :: (a -> b -> b) -> b -> URec Float a -> b foldl :: (b -> a -> b) -> b -> URec Float a -> b foldl' :: (b -> a -> b) -> b -> URec Float a -> b foldr1 :: (a -> a -> a) -> URec Float a -> a foldl1 :: (a -> a -> a) -> URec Float a -> a toList :: URec Float a -> [a] null :: URec Float a -> Bool length :: URec Float a -> Int elem :: Eq a => a -> URec Float a -> Bool maximum :: Ord a => URec Float a -> a minimum :: Ord a => URec Float a -> a sum :: Num a => URec Float a -> a product :: Num a => URec Float a -> a | |
Foldable (URec Int :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Int m -> m foldMap :: Monoid m => (a -> m) -> URec Int a -> m foldr :: (a -> b -> b) -> b -> URec Int a -> b foldr' :: (a -> b -> b) -> b -> URec Int a -> b foldl :: (b -> a -> b) -> b -> URec Int a -> b foldl' :: (b -> a -> b) -> b -> URec Int a -> b foldr1 :: (a -> a -> a) -> URec Int a -> a foldl1 :: (a -> a -> a) -> URec Int a -> a toList :: URec Int a -> [a] null :: URec Int a -> Bool length :: URec Int a -> Int elem :: Eq a => a -> URec Int a -> Bool maximum :: Ord a => URec Int a -> a minimum :: Ord a => URec Int a -> a sum :: Num a => URec Int a -> a product :: Num a => URec Int a -> a | |
Foldable (URec Word :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Word m -> m foldMap :: Monoid m => (a -> m) -> URec Word a -> m foldr :: (a -> b -> b) -> b -> URec Word a -> b foldr' :: (a -> b -> b) -> b -> URec Word a -> b foldl :: (b -> a -> b) -> b -> URec Word a -> b foldl' :: (b -> a -> b) -> b -> URec Word a -> b foldr1 :: (a -> a -> a) -> URec Word a -> a foldl1 :: (a -> a -> a) -> URec Word a -> a toList :: URec Word a -> [a] null :: URec Word a -> Bool length :: URec Word a -> Int elem :: Eq a => a -> URec Word a -> Bool maximum :: Ord a => URec Word a -> a minimum :: Ord a => URec Word a -> a sum :: Num a => URec Word a -> a product :: Num a => URec Word a -> a | |
Foldable (URec (Ptr ()) :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec (Ptr ()) m -> m foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a toList :: URec (Ptr ()) a -> [a] null :: URec (Ptr ()) a -> Bool length :: URec (Ptr ()) a -> Int elem :: Eq a => a -> URec (Ptr ()) a -> Bool maximum :: Ord a => URec (Ptr ()) a -> a minimum :: Ord a => URec (Ptr ()) a -> a sum :: Num a => URec (Ptr ()) a -> a product :: Num a => URec (Ptr ()) a -> a | |
Foldable f => Foldable (Backwards f) | |
Defined in Control.Applicative.Backwards Methods fold :: Monoid m => Backwards f m -> m foldMap :: Monoid m => (a -> m) -> Backwards f a -> m foldr :: (a -> b -> b) -> b -> Backwards f a -> b foldr' :: (a -> b -> b) -> b -> Backwards f a -> b foldl :: (b -> a -> b) -> b -> Backwards f a -> b foldl' :: (b -> a -> b) -> b -> Backwards f a -> b foldr1 :: (a -> a -> a) -> Backwards f a -> a foldl1 :: (a -> a -> a) -> Backwards f a -> a toList :: Backwards f a -> [a] length :: Backwards f a -> Int elem :: Eq a => a -> Backwards f a -> Bool maximum :: Ord a => Backwards f a -> a minimum :: Ord a => Backwards f a -> a | |
Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldr :: (a -> b -> b) -> b -> Const m a -> b foldr' :: (a -> b -> b) -> b -> Const m a -> b foldl :: (b -> a -> b) -> b -> Const m a -> b foldl' :: (b -> a -> b) -> b -> Const m a -> b foldr1 :: (a -> a -> a) -> Const m a -> a foldl1 :: (a -> a -> a) -> Const m a -> a toList :: Const m a -> [a] null :: Const m a -> Bool length :: Const m a -> Int elem :: Eq a => a -> Const m a -> Bool maximum :: Ord a => Const m a -> a minimum :: Ord a => Const m a -> a sum :: Num a => Const m a -> a product :: Num a => Const m a -> a | |
Foldable (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant Methods fold :: Monoid m => Constant a m -> m foldMap :: Monoid m => (a0 -> m) -> Constant a a0 -> m foldr :: (a0 -> b -> b) -> b -> Constant a a0 -> b foldr' :: (a0 -> b -> b) -> b -> Constant a a0 -> b foldl :: (b -> a0 -> b) -> b -> Constant a a0 -> b foldl' :: (b -> a0 -> b) -> b -> Constant a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0 foldl1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0 toList :: Constant a a0 -> [a0] length :: Constant a a0 -> Int elem :: Eq a0 => a0 -> Constant a a0 -> Bool maximum :: Ord a0 => Constant a a0 -> a0 minimum :: Ord a0 => Constant a a0 -> a0 | |
Foldable f => Foldable (Ap f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m foldMap :: Monoid m => (a -> m) -> Ap f a -> m foldr :: (a -> b -> b) -> b -> Ap f a -> b foldr' :: (a -> b -> b) -> b -> Ap f a -> b foldl :: (b -> a -> b) -> b -> Ap f a -> b foldl' :: (b -> a -> b) -> b -> Ap f a -> b foldr1 :: (a -> a -> a) -> Ap f a -> a foldl1 :: (a -> a -> a) -> Ap f a -> a toList :: Ap f a -> [a] null :: Ap f a -> Bool length :: Ap f a -> Int elem :: Eq a => a -> Ap f a -> Bool maximum :: Ord a => Ap f a -> a minimum :: Ord a => Ap f a -> a sum :: Num a => Ap f a -> a product :: Num a => Ap f a -> a | |
Foldable f => Foldable (Alt f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m foldMap :: Monoid m => (a -> m) -> Alt f a -> m foldr :: (a -> b -> b) -> b -> Alt f a -> b foldr' :: (a -> b -> b) -> b -> Alt f a -> b foldl :: (b -> a -> b) -> b -> Alt f a -> b foldl' :: (b -> a -> b) -> b -> Alt f a -> b foldr1 :: (a -> a -> a) -> Alt f a -> a foldl1 :: (a -> a -> a) -> Alt f a -> a toList :: Alt f a -> [a] null :: Alt f a -> Bool length :: Alt f a -> Int elem :: Eq a => a -> Alt f a -> Bool maximum :: Ord a => Alt f a -> a minimum :: Ord a => Alt f a -> a sum :: Num a => Alt f a -> a product :: Num a => Alt f a -> a | |
Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a foldl1 :: (a -> a -> a) -> WriterT w f a -> a toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool length :: WriterT w f a -> Int elem :: Eq a => a -> WriterT w f a -> Bool maximum :: Ord a => WriterT w f a -> a minimum :: Ord a => WriterT w f a -> a sum :: Num a => WriterT w f a -> a product :: Num a => WriterT w f a -> a | |
Foldable (K1 i c :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m foldMap :: Monoid m => (a -> m) -> K1 i c a -> m foldr :: (a -> b -> b) -> b -> K1 i c a -> b foldr' :: (a -> b -> b) -> b -> K1 i c a -> b foldl :: (b -> a -> b) -> b -> K1 i c a -> b foldl' :: (b -> a -> b) -> b -> K1 i c a -> b foldr1 :: (a -> a -> a) -> K1 i c a -> a foldl1 :: (a -> a -> a) -> K1 i c a -> a toList :: K1 i c a -> [a] null :: K1 i c a -> Bool length :: K1 i c a -> Int elem :: Eq a => a -> K1 i c a -> Bool maximum :: Ord a => K1 i c a -> a minimum :: Ord a => K1 i c a -> a sum :: Num a => K1 i c a -> a product :: Num a => K1 i c a -> a | |
(Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b foldr1 :: (a -> a -> a) -> (f :+: g) a -> a foldl1 :: (a -> a -> a) -> (f :+: g) a -> a toList :: (f :+: g) a -> [a] null :: (f :+: g) a -> Bool length :: (f :+: g) a -> Int elem :: Eq a => a -> (f :+: g) a -> Bool maximum :: Ord a => (f :+: g) a -> a minimum :: Ord a => (f :+: g) a -> a sum :: Num a => (f :+: g) a -> a product :: Num a => (f :+: g) a -> a | |
(Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :*: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b foldr1 :: (a -> a -> a) -> (f :*: g) a -> a foldl1 :: (a -> a -> a) -> (f :*: g) a -> a toList :: (f :*: g) a -> [a] null :: (f :*: g) a -> Bool length :: (f :*: g) a -> Int elem :: Eq a => a -> (f :*: g) a -> Bool maximum :: Ord a => (f :*: g) a -> a minimum :: Ord a => (f :*: g) a -> a sum :: Num a => (f :*: g) a -> a product :: Num a => (f :*: g) a -> a | |
Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m foldr :: (a -> b -> b) -> b -> M1 i c f a -> b foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b foldl :: (b -> a -> b) -> b -> M1 i c f a -> b foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b foldr1 :: (a -> a -> a) -> M1 i c f a -> a foldl1 :: (a -> a -> a) -> M1 i c f a -> a toList :: M1 i c f a -> [a] null :: M1 i c f a -> Bool length :: M1 i c f a -> Int elem :: Eq a => a -> M1 i c f a -> Bool maximum :: Ord a => M1 i c f a -> a minimum :: Ord a => M1 i c f a -> a sum :: Num a => M1 i c f a -> a product :: Num a => M1 i c f a -> a | |
(Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b foldr1 :: (a -> a -> a) -> (f :.: g) a -> a foldl1 :: (a -> a -> a) -> (f :.: g) a -> a toList :: (f :.: g) a -> [a] null :: (f :.: g) a -> Bool length :: (f :.: g) a -> Int elem :: Eq a => a -> (f :.: g) a -> Bool maximum :: Ord a => (f :.: g) a -> a minimum :: Ord a => (f :.: g) a -> a sum :: Num a => (f :.: g) a -> a product :: Num a => (f :.: g) a -> a | |
(Foldable f, Foldable g) => Foldable (Compose f g) | |
Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m foldMap :: Monoid m => (a -> m) -> Compose f g a -> m foldr :: (a -> b -> b) -> b -> Compose f g a -> b foldr' :: (a -> b -> b) -> b -> Compose f g a -> b foldl :: (b -> a -> b) -> b -> Compose f g a -> b foldl' :: (b -> a -> b) -> b -> Compose f g a -> b foldr1 :: (a -> a -> a) -> Compose f g a -> a foldl1 :: (a -> a -> a) -> Compose f g a -> a toList :: Compose f g a -> [a] null :: Compose f g a -> Bool length :: Compose f g a -> Int elem :: Eq a => a -> Compose f g a -> Bool maximum :: Ord a => Compose f g a -> a minimum :: Ord a => Compose f g a -> a sum :: Num a => Compose f g a -> a product :: Num a => Compose f g a -> a |
class Semigroup a => Monoid a #
Minimal complete definition
mempty
Instances
Monoid Ordering | |
Monoid () | |
Monoid Any | |
Monoid All | |
Monoid IntSet | |
Defined in Data.IntSet.Internal | |
Monoid [a] | |
Semigroup a => Monoid (Maybe a) | |
Monoid a => Monoid (IO a) | |
Monoid p => Monoid (Par1 p) | |
Defined in GHC.Generics | |
Num a => Monoid (Product a) | |
Num a => Monoid (Sum a) | |
Monoid a => Monoid (Identity a) | |
Monoid a => Monoid (Dual a) | |
Defined in Data.Semigroup.Internal | |
Monoid (Endo a) | |
Defined in Data.Semigroup.Internal | |
Monoid (First a) | |
Monoid (Last a) | |
Monoid a => Monoid (Down a) | |
Monoid (IntMap a) | |
Defined in Data.IntMap.Internal | |
Ord a => Monoid (Set a) | |
Defined in Data.Set.Internal | |
Monoid (MergeSet a) | |
Defined in Data.Set.Internal | |
Monoid b => Monoid (a -> b) | |
Monoid (U1 p) | |
Defined in GHC.Generics | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid (Proxy s) | |
Defined in Data.Proxy | |
Ord k => Monoid (Map k v) | |
Defined in Data.Map.Internal | |
Monoid (f p) => Monoid (Rec1 f p) | |
Defined in GHC.Generics | |
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
Monoid a => Monoid (Const a b) | |
Defined in Data.Functor.Const | |
Monoid a => Monoid (Constant a b) | |
(Applicative f, Monoid a) => Monoid (Ap f a) | |
Defined in Data.Monoid | |
Alternative f => Monoid (Alt f a) | |
Defined in Data.Semigroup.Internal | |
Monoid c => Monoid (K1 i c p) | |
Defined in GHC.Generics | |
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
Defined in GHC.Generics | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
Monoid (f p) => Monoid (M1 i c f p) | |
Defined in GHC.Generics | |
Monoid (f (g p)) => Monoid ((f :.: g) p) | |
Defined in GHC.Generics | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
data Backwards (f :: k -> Type) (a :: k) :: forall k. (k -> Type) -> k -> Type #
Instances
Functor f => Functor (Backwards f) | |
Applicative f => Applicative (Backwards f) | |
Defined in Control.Applicative.Backwards | |
Foldable f => Foldable (Backwards f) | |
Defined in Control.Applicative.Backwards Methods fold :: Monoid m => Backwards f m -> m foldMap :: Monoid m => (a -> m) -> Backwards f a -> m foldr :: (a -> b -> b) -> b -> Backwards f a -> b foldr' :: (a -> b -> b) -> b -> Backwards f a -> b foldl :: (b -> a -> b) -> b -> Backwards f a -> b foldl' :: (b -> a -> b) -> b -> Backwards f a -> b foldr1 :: (a -> a -> a) -> Backwards f a -> a foldl1 :: (a -> a -> a) -> Backwards f a -> a toList :: Backwards f a -> [a] length :: Backwards f a -> Int elem :: Eq a => a -> Backwards f a -> Bool maximum :: Ord a => Backwards f a -> a minimum :: Ord a => Backwards f a -> a | |
Traversable f => Traversable (Backwards f) | |
Defined in Control.Applicative.Backwards | |
Alternative f => Alternative (Backwards f) | |
Contravariant f => Contravariant (Backwards f) | |
Eq1 f => Eq1 (Backwards f) | |
Defined in Control.Applicative.Backwards | |
Ord1 f => Ord1 (Backwards f) | |
Defined in Control.Applicative.Backwards Methods liftCompare :: (a -> b -> Ordering) -> Backwards f a -> Backwards f b -> Ordering | |
Read1 f => Read1 (Backwards f) | |
Defined in Control.Applicative.Backwards Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Backwards f a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Backwards f a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Backwards f a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Backwards f a] | |
Show1 f => Show1 (Backwards f) | |
Defined in Control.Applicative.Backwards Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Backwards f a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Backwards f a] -> ShowS | |
Identical f => Identical (Backwards f) Source # | |
Defined in Lens.Family.Identical | |
Phantom f => Phantom (Backwards f) Source # | |
Defined in Lens.Family.Phantom | |
(Eq1 f, Eq a) => Eq (Backwards f a) | |
(Ord1 f, Ord a) => Ord (Backwards f a) | |
Defined in Control.Applicative.Backwards | |
(Read1 f, Read a) => Read (Backwards f a) | |
Defined in Control.Applicative.Backwards | |
(Show1 f, Show a) => Show (Backwards f a) | |
Instances
Bounded All | |
Defined in Data.Semigroup.Internal | |
Eq All | |
Ord All | |
Read All | |
Defined in Data.Semigroup.Internal | |
Show All | |
Generic All | |
Semigroup All | |
Monoid All | |
type Rep All | |
Defined in Data.Semigroup.Internal type Rep All = D1 (MetaData "All" "Data.Semigroup.Internal" "base" True) (C1 (MetaCons "All" PrefixI True) (S1 (MetaSel (Just "getAll") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))) |
Instances
Bounded Any | |
Defined in Data.Semigroup.Internal | |
Eq Any | |
Ord Any | |
Read Any | |
Defined in Data.Semigroup.Internal | |
Show Any | |
Generic Any | |
Semigroup Any | |
Monoid Any | |
type Rep Any | |
Defined in Data.Semigroup.Internal type Rep Any = D1 (MetaData "Any" "Data.Semigroup.Internal" "base" True) (C1 (MetaCons "Any" PrefixI True) (S1 (MetaSel (Just "getAny") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))) |
Instances
Monad First | |
Functor First | |
Applicative First | |
Foldable First | |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a foldl1 :: (a -> a -> a) -> First a -> a elem :: Eq a => a -> First a -> Bool maximum :: Ord a => First a -> a | |
Traversable First | |
Defined in Data.Traversable | |
Eq a => Eq (First a) | |
Ord a => Ord (First a) | |
Read a => Read (First a) | |
Defined in Data.Monoid | |
Show a => Show (First a) | |
Generic (First a) | |
Semigroup (First a) | |
Monoid (First a) | |
Generic1 First | |
type Rep (First a) | |
Defined in Data.Monoid type Rep (First a) = D1 (MetaData "First" "Data.Monoid" "base" True) (C1 (MetaCons "First" PrefixI True) (S1 (MetaSel (Just "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe a)))) | |
type Rep1 First | |
Defined in Data.Monoid type Rep1 First = D1 (MetaData "First" "Data.Monoid" "base" True) (C1 (MetaCons "First" PrefixI True) (S1 (MetaSel (Just "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Maybe))) |
Instances
Monad Last | |
Functor Last | |
Applicative Last | |
Foldable Last | |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a foldl1 :: (a -> a -> a) -> Last a -> a elem :: Eq a => a -> Last a -> Bool maximum :: Ord a => Last a -> a | |
Traversable Last | |
Defined in Data.Traversable | |
Eq a => Eq (Last a) | |
Ord a => Ord (Last a) | |
Read a => Read (Last a) | |
Defined in Data.Monoid | |
Show a => Show (Last a) | |
Generic (Last a) | |
Semigroup (Last a) | |
Monoid (Last a) | |
Generic1 Last | |
type Rep (Last a) | |
Defined in Data.Monoid type Rep (Last a) = D1 (MetaData "Last" "Data.Monoid" "base" True) (C1 (MetaCons "Last" PrefixI True) (S1 (MetaSel (Just "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe a)))) | |
type Rep1 Last | |
Defined in Data.Monoid type Rep1 Last = D1 (MetaData "Last" "Data.Monoid" "base" True) (C1 (MetaCons "Last" PrefixI True) (S1 (MetaSel (Just "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Maybe))) |
Instances
Monad Sum | |
Functor Sum | |
Applicative Sum | |
Foldable Sum | |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m foldr :: (a -> b -> b) -> b -> Sum a -> b foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b foldl' :: (b -> a -> b) -> b -> Sum a -> b foldr1 :: (a -> a -> a) -> Sum a -> a foldl1 :: (a -> a -> a) -> Sum a -> a elem :: Eq a => a -> Sum a -> Bool maximum :: Ord a => Sum a -> a | |
Traversable Sum | |
Defined in Data.Traversable | |
Bounded a => Bounded (Sum a) | |
Defined in Data.Semigroup.Internal | |
Eq a => Eq (Sum a) | |
Num a => Num (Sum a) | |
Ord a => Ord (Sum a) | |
Read a => Read (Sum a) | |
Defined in Data.Semigroup.Internal | |
Show a => Show (Sum a) | |
Generic (Sum a) | |
Num a => Semigroup (Sum a) | |
Num a => Monoid (Sum a) | |
Generic1 Sum | |
type Rep (Sum a) | |
Defined in Data.Semigroup.Internal type Rep (Sum a) = D1 (MetaData "Sum" "Data.Semigroup.Internal" "base" True) (C1 (MetaCons "Sum" PrefixI True) (S1 (MetaSel (Just "getSum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) | |
type Rep1 Sum | |
Defined in Data.Semigroup.Internal type Rep1 Sum = D1 (MetaData "Sum" "Data.Semigroup.Internal" "base" True) (C1 (MetaCons "Sum" PrefixI True) (S1 (MetaSel (Just "getSum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)) |
Instances
Monad Product | |
Functor Product | |
Applicative Product | |
Foldable Product | |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m foldr :: (a -> b -> b) -> b -> Product a -> b foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b foldl' :: (b -> a -> b) -> b -> Product a -> b foldr1 :: (a -> a -> a) -> Product a -> a foldl1 :: (a -> a -> a) -> Product a -> a elem :: Eq a => a -> Product a -> Bool maximum :: Ord a => Product a -> a minimum :: Ord a => Product a -> a | |
Traversable Product | |
Defined in Data.Traversable | |
Bounded a => Bounded (Product a) | |
Defined in Data.Semigroup.Internal | |
Eq a => Eq (Product a) | |
Num a => Num (Product a) | |
Ord a => Ord (Product a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (Product a) | |
Defined in Data.Semigroup.Internal | |
Show a => Show (Product a) | |
Generic (Product a) | |
Num a => Semigroup (Product a) | |
Num a => Monoid (Product a) | |
Generic1 Product | |
type Rep (Product a) | |
Defined in Data.Semigroup.Internal type Rep (Product a) = D1 (MetaData "Product" "Data.Semigroup.Internal" "base" True) (C1 (MetaCons "Product" PrefixI True) (S1 (MetaSel (Just "getProduct") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) | |
type Rep1 Product | |
Defined in Data.Semigroup.Internal type Rep1 Product = D1 (MetaData "Product" "Data.Semigroup.Internal" "base" True) (C1 (MetaCons "Product" PrefixI True) (S1 (MetaSel (Just "getProduct") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)) |