Data.Comp.Derive

This module contains functionality for automatically deriving boilerplate code using Template Haskell. Examples include instances of Functor, Foldable, and Traversable.

Documentation

derive :: [Name -> Q [Dec]] -> [Name] -> Q [Dec]

Helper function for generating a list of instances for a list of named signatures. For example, in order to derive instances Functor and ShowF for a signature Exp, use derive as follows (requires Template Haskell):

$(derive [makeFunctor, makeShowF] [''Exp])

Derive boilerplate instances for compositional data type signatures.

ShowF

class ShowF f where

Signature printing. An instance ShowF f gives rise to an instance Show (Term f).

Minimal complete definition

showF

Methods

showF :: f String -> String

makeShowF :: Name -> Q [Dec]

Derive an instance of ShowF for a type constructor of any first-order kind taking at least one argument.

class ShowConstr f where

Constructor printing.

Minimal complete definition

showConstr

Methods

showConstr :: f a -> String

makeShowConstr :: Name -> Q [Dec]

Derive an instance of showConstr for a type constructor of any first-order kind taking at least one argument.

EqF

class EqF f where

Signature equality. An instance EqF f gives rise to an instance Eq (Term f).

Minimal complete definition

eqF

Methods

eqF :: Eq a => f a -> f a -> Bool

makeEqF :: Name -> Q [Dec]

Derive an instance of EqF for a type constructor of any first-order kind taking at least one argument.

OrdF

class EqF f => OrdF f where

Signature ordering. An instance OrdF f gives rise to an instance Ord (Term f).

Minimal complete definition

compareF

Methods

compareF :: Ord a => f a -> f a -> Ordering

makeOrdF :: Name -> Q [Dec]

Derive an instance of OrdF for a type constructor of any first-order kind taking at least one argument.

Foldable

class Foldable t

Data structures that can be folded.

For example, given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Foldable Tree where
   foldMap f Empty = mempty
   foldMap f (Leaf x) = f x
   foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr:

instance Foldable Tree where
   foldr f z Empty = z
   foldr f z (Leaf x) = f x z
   foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

Foldable instances are expected to satisfy the following laws:

foldr f z t = appEndo (foldMap (Endo . f) t ) z

foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z

fold = foldMap id

sum, product, maximum, and minimum should all be essentially equivalent to foldMap forms, such as

sum = getSum . foldMap Sum

but may be less defined.

If the type is also a Functor instance, it should satisfy

foldMap f = fold . fmap f

which implies that

foldMap f . fmap g = foldMap (f . g)

Minimal complete definition

foldMap | foldr

Instances

Foldable []

Methods

fold :: Monoid m => [m] -> m

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

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 V1

Methods

fold :: Monoid m => V1 m -> m

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

Methods

fold :: Monoid m => U1 m -> m

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 Par1

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 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

toList :: Identity a -> [a]

null :: Identity a -> Bool

length :: Identity a -> Int

elem :: Eq a => a -> Identity a -> Bool

maximum :: Ord a => Identity a -> a

minimum :: Ord a => Identity a -> a

sum :: Num a => Identity a -> a

product :: Num a => Identity a -> a

Foldable Min

Methods

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

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

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

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

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

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

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

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

toList :: Min a -> [a]

null :: Min a -> Bool

length :: Min a -> Int

elem :: Eq a => a -> Min a -> Bool

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

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

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

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

Foldable Max

Methods

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

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

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

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

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

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

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

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

toList :: Max a -> [a]

null :: Max a -> Bool

length :: Max a -> Int

elem :: Eq a => a -> Max a -> Bool

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

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

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

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

Foldable First

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

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

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

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

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

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

Foldable Last

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

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

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

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

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

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

Foldable Option

Methods

fold :: Monoid m => Option m -> m

foldMap :: Monoid m => (a -> m) -> Option a -> m

foldr :: (a -> b -> b) -> b -> Option a -> b

foldr' :: (a -> b -> b) -> b -> Option a -> b

foldl :: (b -> a -> b) -> b -> Option a -> b

foldl' :: (b -> a -> b) -> b -> Option a -> b

foldr1 :: (a -> a -> a) -> Option a -> a

foldl1 :: (a -> a -> a) -> Option a -> a

toList :: Option a -> [a]

null :: Option a -> Bool

length :: Option a -> Int

elem :: Eq a => a -> Option a -> Bool

maximum :: Ord a => Option a -> a

minimum :: Ord a => Option a -> a

sum :: Num a => Option a -> a

product :: Num a => Option a -> a

Foldable NonEmpty

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 Complex

Methods

fold :: Monoid m => Complex m -> m

foldMap :: Monoid m => (a -> m) -> Complex a -> m

foldr :: (a -> b -> b) -> b -> Complex a -> b

foldr' :: (a -> b -> b) -> b -> Complex a -> b

foldl :: (b -> a -> b) -> b -> Complex a -> b

foldl' :: (b -> a -> b) -> b -> Complex a -> b

foldr1 :: (a -> a -> a) -> Complex a -> a

foldl1 :: (a -> a -> a) -> Complex a -> a

toList :: Complex a -> [a]

null :: Complex a -> Bool

length :: Complex a -> Int

elem :: Eq a => a -> Complex a -> Bool

maximum :: Ord a => Complex a -> a

minimum :: Ord a => Complex a -> a

sum :: Num a => Complex a -> a

product :: Num a => Complex a -> a

Foldable ZipList

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 Dual

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 Sum

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

toList :: Sum a -> [a]

null :: Sum a -> Bool

length :: Sum a -> Int

elem :: Eq a => a -> Sum a -> Bool

maximum :: Ord a => Sum a -> a

minimum :: Ord a => Sum a -> a

sum :: Num a => Sum a -> a

product :: Num a => Sum a -> a

Foldable Product

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

toList :: Product a -> [a]

null :: Product a -> Bool

length :: Product a -> Int

elem :: Eq a => a -> Product a -> Bool

maximum :: Ord a => Product a -> a

minimum :: Ord a => Product a -> a

sum :: Num a => Product a -> a

product :: Num a => Product a -> a

Foldable First

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

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

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

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

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

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

Foldable Last

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

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

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

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

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

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

Foldable Digit

Methods

fold :: Monoid m => Digit m -> m

foldMap :: Monoid m => (a -> m) -> Digit a -> m

foldr :: (a -> b -> b) -> b -> Digit a -> b

foldr' :: (a -> b -> b) -> b -> Digit a -> b

foldl :: (b -> a -> b) -> b -> Digit a -> b

foldl' :: (b -> a -> b) -> b -> Digit a -> b

foldr1 :: (a -> a -> a) -> Digit a -> a

foldl1 :: (a -> a -> a) -> Digit a -> a

toList :: Digit a -> [a]

null :: Digit a -> Bool

length :: Digit a -> Int

elem :: Eq a => a -> Digit a -> Bool

maximum :: Ord a => Digit a -> a

minimum :: Ord a => Digit a -> a

sum :: Num a => Digit a -> a

product :: Num a => Digit a -> a

Foldable Node

Methods

fold :: Monoid m => Node m -> m

foldMap :: Monoid m => (a -> m) -> Node a -> m

foldr :: (a -> b -> b) -> b -> Node a -> b

foldr' :: (a -> b -> b) -> b -> Node a -> b

foldl :: (b -> a -> b) -> b -> Node a -> b

foldl' :: (b -> a -> b) -> b -> Node a -> b

foldr1 :: (a -> a -> a) -> Node a -> a

foldl1 :: (a -> a -> a) -> Node a -> a

toList :: Node a -> [a]

null :: Node a -> Bool

length :: Node a -> Int

elem :: Eq a => a -> Node a -> Bool

maximum :: Ord a => Node a -> a

minimum :: Ord a => Node a -> a

sum :: Num a => Node a -> a

product :: Num a => Node a -> a

Foldable Elem

Methods

fold :: Monoid m => Elem m -> m

foldMap :: Monoid m => (a -> m) -> Elem a -> m

foldr :: (a -> b -> b) -> b -> Elem a -> b

foldr' :: (a -> b -> b) -> b -> Elem a -> b

foldl :: (b -> a -> b) -> b -> Elem a -> b

foldl' :: (b -> a -> b) -> b -> Elem a -> b

foldr1 :: (a -> a -> a) -> Elem a -> a

foldl1 :: (a -> a -> a) -> Elem a -> a

toList :: Elem a -> [a]

null :: Elem a -> Bool

length :: Elem a -> Int

elem :: Eq a => a -> Elem a -> Bool

maximum :: Ord a => Elem a -> a

minimum :: Ord a => Elem a -> a

sum :: Num a => Elem a -> a

product :: Num a => Elem a -> a

Foldable FingerTree

Methods

fold :: Monoid m => FingerTree m -> m

foldMap :: Monoid m => (a -> m) -> FingerTree a -> m

foldr :: (a -> b -> b) -> b -> FingerTree a -> b

foldr' :: (a -> b -> b) -> b -> FingerTree a -> b

foldl :: (b -> a -> b) -> b -> FingerTree a -> b

foldl' :: (b -> a -> b) -> b -> FingerTree a -> b

foldr1 :: (a -> a -> a) -> FingerTree a -> a

foldl1 :: (a -> a -> a) -> FingerTree a -> a

toList :: FingerTree a -> [a]

null :: FingerTree a -> Bool

length :: FingerTree a -> Int

elem :: Eq a => a -> FingerTree a -> Bool

maximum :: Ord a => FingerTree a -> a

minimum :: Ord a => FingerTree a -> a

sum :: Num a => FingerTree a -> a

product :: Num a => FingerTree a -> a

Foldable IntMap

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 Tree

Methods

fold :: Monoid m => Tree m -> m

foldMap :: Monoid m => (a -> m) -> Tree a -> m

foldr :: (a -> b -> b) -> b -> Tree a -> b

foldr' :: (a -> b -> b) -> b -> Tree a -> b

foldl :: (b -> a -> b) -> b -> Tree a -> b

foldl' :: (b -> a -> b) -> b -> Tree a -> b

foldr1 :: (a -> a -> a) -> Tree a -> a

foldl1 :: (a -> a -> a) -> Tree a -> a

toList :: Tree a -> [a]

null :: Tree a -> Bool

length :: Tree a -> Int

elem :: Eq a => a -> Tree a -> Bool

maximum :: Ord a => Tree a -> a

minimum :: Ord a => Tree a -> a

sum :: Num a => Tree a -> a

product :: Num a => Tree a -> a

Foldable Seq

Methods

fold :: Monoid m => Seq m -> m

foldMap :: Monoid m => (a -> m) -> Seq a -> m

foldr :: (a -> b -> b) -> b -> Seq a -> b

foldr' :: (a -> b -> b) -> b -> Seq a -> b

foldl :: (b -> a -> b) -> b -> Seq a -> b

foldl' :: (b -> a -> b) -> b -> Seq a -> b

foldr1 :: (a -> a -> a) -> Seq a -> a

foldl1 :: (a -> a -> a) -> Seq a -> a

toList :: Seq a -> [a]

null :: Seq a -> Bool

length :: Seq a -> Int

elem :: Eq a => a -> Seq a -> Bool

maximum :: Ord a => Seq a -> a

minimum :: Ord a => Seq a -> a

sum :: Num a => Seq a -> a

product :: Num a => Seq a -> a

Foldable ViewL

Methods

fold :: Monoid m => ViewL m -> m

foldMap :: Monoid m => (a -> m) -> ViewL a -> m

foldr :: (a -> b -> b) -> b -> ViewL a -> b

foldr' :: (a -> b -> b) -> b -> ViewL a -> b

foldl :: (b -> a -> b) -> b -> ViewL a -> b

foldl' :: (b -> a -> b) -> b -> ViewL a -> b

foldr1 :: (a -> a -> a) -> ViewL a -> a

foldl1 :: (a -> a -> a) -> ViewL a -> a

toList :: ViewL a -> [a]

null :: ViewL a -> Bool

length :: ViewL a -> Int

elem :: Eq a => a -> ViewL a -> Bool

maximum :: Ord a => ViewL a -> a

minimum :: Ord a => ViewL a -> a

sum :: Num a => ViewL a -> a

product :: Num a => ViewL a -> a

Foldable ViewR

Methods

fold :: Monoid m => ViewR m -> m

foldMap :: Monoid m => (a -> m) -> ViewR a -> m

foldr :: (a -> b -> b) -> b -> ViewR a -> b

foldr' :: (a -> b -> b) -> b -> ViewR a -> b

foldl :: (b -> a -> b) -> b -> ViewR a -> b

foldl' :: (b -> a -> b) -> b -> ViewR a -> b

foldr1 :: (a -> a -> a) -> ViewR a -> a

foldl1 :: (a -> a -> a) -> ViewR a -> a

toList :: ViewR a -> [a]

null :: ViewR a -> Bool

length :: ViewR a -> Int

elem :: Eq a => a -> ViewR a -> Bool

maximum :: Ord a => ViewR a -> a

minimum :: Ord a => ViewR a -> a

sum :: Num a => ViewR a -> a

product :: Num a => ViewR a -> a

Foldable Set

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 Alt

Methods

fold :: Monoid m => Alt m -> m

foldMap :: Monoid m => (a -> m) -> Alt a -> m

foldr :: (a -> b -> b) -> b -> Alt a -> b

foldr' :: (a -> b -> b) -> b -> Alt a -> b

foldl :: (b -> a -> b) -> b -> Alt a -> b

foldl' :: (b -> a -> b) -> b -> Alt a -> b

foldr1 :: (a -> a -> a) -> Alt a -> a

foldl1 :: (a -> a -> a) -> Alt a -> a

toList :: Alt a -> [a]

null :: Alt a -> Bool

length :: Alt a -> Int

elem :: Eq a => a -> Alt a -> Bool

maximum :: Ord a => Alt a -> a

minimum :: Ord a => Alt a -> a

sum :: Num a => Alt a -> a

product :: Num a => Alt a -> a

Foldable FieldUpdate

Methods

fold :: Monoid m => FieldUpdate m -> m

foldMap :: Monoid m => (a -> m) -> FieldUpdate a -> m

foldr :: (a -> b -> b) -> b -> FieldUpdate a -> b

foldr' :: (a -> b -> b) -> b -> FieldUpdate a -> b

foldl :: (b -> a -> b) -> b -> FieldUpdate a -> b

foldl' :: (b -> a -> b) -> b -> FieldUpdate a -> b

foldr1 :: (a -> a -> a) -> FieldUpdate a -> a

foldl1 :: (a -> a -> a) -> FieldUpdate a -> a

toList :: FieldUpdate a -> [a]

null :: FieldUpdate a -> Bool

length :: FieldUpdate a -> Int

elem :: Eq a => a -> FieldUpdate a -> Bool

maximum :: Ord a => FieldUpdate a -> a

minimum :: Ord a => FieldUpdate a -> a

sum :: Num a => FieldUpdate a -> a

product :: Num a => FieldUpdate a -> a

Foldable QualStmt

Methods

fold :: Monoid m => QualStmt m -> m

foldMap :: Monoid m => (a -> m) -> QualStmt a -> m

foldr :: (a -> b -> b) -> b -> QualStmt a -> b

foldr' :: (a -> b -> b) -> b -> QualStmt a -> b

foldl :: (b -> a -> b) -> b -> QualStmt a -> b

foldl' :: (b -> a -> b) -> b -> QualStmt a -> b

foldr1 :: (a -> a -> a) -> QualStmt a -> a

foldl1 :: (a -> a -> a) -> QualStmt a -> a

toList :: QualStmt a -> [a]

null :: QualStmt a -> Bool

length :: QualStmt a -> Int

elem :: Eq a => a -> QualStmt a -> Bool

maximum :: Ord a => QualStmt a -> a

minimum :: Ord a => QualStmt a -> a

sum :: Num a => QualStmt a -> a

product :: Num a => QualStmt a -> a

Foldable Stmt

Methods

fold :: Monoid m => Stmt m -> m

foldMap :: Monoid m => (a -> m) -> Stmt a -> m

foldr :: (a -> b -> b) -> b -> Stmt a -> b

foldr' :: (a -> b -> b) -> b -> Stmt a -> b

foldl :: (b -> a -> b) -> b -> Stmt a -> b

foldl' :: (b -> a -> b) -> b -> Stmt a -> b

foldr1 :: (a -> a -> a) -> Stmt a -> a

foldl1 :: (a -> a -> a) -> Stmt a -> a

toList :: Stmt a -> [a]

null :: Stmt a -> Bool

length :: Stmt a -> Int

elem :: Eq a => a -> Stmt a -> Bool

maximum :: Ord a => Stmt a -> a

minimum :: Ord a => Stmt a -> a

sum :: Num a => Stmt a -> a

product :: Num a => Stmt a -> a

Foldable PatField

Methods

fold :: Monoid m => PatField m -> m

foldMap :: Monoid m => (a -> m) -> PatField a -> m

foldr :: (a -> b -> b) -> b -> PatField a -> b

foldr' :: (a -> b -> b) -> b -> PatField a -> b

foldl :: (b -> a -> b) -> b -> PatField a -> b

foldl' :: (b -> a -> b) -> b -> PatField a -> b

foldr1 :: (a -> a -> a) -> PatField a -> a

foldl1 :: (a -> a -> a) -> PatField a -> a

toList :: PatField a -> [a]

null :: PatField a -> Bool

length :: PatField a -> Int

elem :: Eq a => a -> PatField a -> Bool

maximum :: Ord a => PatField a -> a

minimum :: Ord a => PatField a -> a

sum :: Num a => PatField a -> a

product :: Num a => PatField a -> a

Foldable RPat

Methods

fold :: Monoid m => RPat m -> m

foldMap :: Monoid m => (a -> m) -> RPat a -> m

foldr :: (a -> b -> b) -> b -> RPat a -> b

foldr' :: (a -> b -> b) -> b -> RPat a -> b

foldl :: (b -> a -> b) -> b -> RPat a -> b

foldl' :: (b -> a -> b) -> b -> RPat a -> b

foldr1 :: (a -> a -> a) -> RPat a -> a

foldl1 :: (a -> a -> a) -> RPat a -> a

toList :: RPat a -> [a]

null :: RPat a -> Bool

length :: RPat a -> Int

elem :: Eq a => a -> RPat a -> Bool

maximum :: Ord a => RPat a -> a

minimum :: Ord a => RPat a -> a

sum :: Num a => RPat a -> a

product :: Num a => RPat a -> a

Foldable RPatOp

Methods

fold :: Monoid m => RPatOp m -> m

foldMap :: Monoid m => (a -> m) -> RPatOp a -> m

foldr :: (a -> b -> b) -> b -> RPatOp a -> b

foldr' :: (a -> b -> b) -> b -> RPatOp a -> b

foldl :: (b -> a -> b) -> b -> RPatOp a -> b

foldl' :: (b -> a -> b) -> b -> RPatOp a -> b

foldr1 :: (a -> a -> a) -> RPatOp a -> a

foldl1 :: (a -> a -> a) -> RPatOp a -> a

toList :: RPatOp a -> [a]

null :: RPatOp a -> Bool

length :: RPatOp a -> Int

elem :: Eq a => a -> RPatOp a -> Bool

maximum :: Ord a => RPatOp a -> a

minimum :: Ord a => RPatOp a -> a

sum :: Num a => RPatOp a -> a

product :: Num a => RPatOp a -> a

Foldable PXAttr

Methods

fold :: Monoid m => PXAttr m -> m

foldMap :: Monoid m => (a -> m) -> PXAttr a -> m

foldr :: (a -> b -> b) -> b -> PXAttr a -> b

foldr' :: (a -> b -> b) -> b -> PXAttr a -> b

foldl :: (b -> a -> b) -> b -> PXAttr a -> b

foldl' :: (b -> a -> b) -> b -> PXAttr a -> b

foldr1 :: (a -> a -> a) -> PXAttr a -> a

foldl1 :: (a -> a -> a) -> PXAttr a -> a

toList :: PXAttr a -> [a]

null :: PXAttr a -> Bool

length :: PXAttr a -> Int

elem :: Eq a => a -> PXAttr a -> Bool

maximum :: Ord a => PXAttr a -> a

minimum :: Ord a => PXAttr a -> a

sum :: Num a => PXAttr a -> a

product :: Num a => PXAttr a -> a

Foldable Pat

Methods

fold :: Monoid m => Pat m -> m

foldMap :: Monoid m => (a -> m) -> Pat a -> m

foldr :: (a -> b -> b) -> b -> Pat a -> b

foldr' :: (a -> b -> b) -> b -> Pat a -> b

foldl :: (b -> a -> b) -> b -> Pat a -> b

foldl' :: (b -> a -> b) -> b -> Pat a -> b

foldr1 :: (a -> a -> a) -> Pat a -> a

foldl1 :: (a -> a -> a) -> Pat a -> a

toList :: Pat a -> [a]

null :: Pat a -> Bool

length :: Pat a -> Int

elem :: Eq a => a -> Pat a -> Bool

maximum :: Ord a => Pat a -> a

minimum :: Ord a => Pat a -> a

sum :: Num a => Pat a -> a

product :: Num a => Pat a -> a

Foldable WarningText

Methods

fold :: Monoid m => WarningText m -> m

foldMap :: Monoid m => (a -> m) -> WarningText a -> m

foldr :: (a -> b -> b) -> b -> WarningText a -> b

foldr' :: (a -> b -> b) -> b -> WarningText a -> b

foldl :: (b -> a -> b) -> b -> WarningText a -> b

foldl' :: (b -> a -> b) -> b -> WarningText a -> b

foldr1 :: (a -> a -> a) -> WarningText a -> a

foldl1 :: (a -> a -> a) -> WarningText a -> a

toList :: WarningText a -> [a]

null :: WarningText a -> Bool

length :: WarningText a -> Int

elem :: Eq a => a -> WarningText a -> Bool

maximum :: Ord a => WarningText a -> a

minimum :: Ord a => WarningText a -> a

sum :: Num a => WarningText a -> a

product :: Num a => WarningText a -> a

Foldable RuleVar

Methods

fold :: Monoid m => RuleVar m -> m

foldMap :: Monoid m => (a -> m) -> RuleVar a -> m

foldr :: (a -> b -> b) -> b -> RuleVar a -> b

foldr' :: (a -> b -> b) -> b -> RuleVar a -> b

foldl :: (b -> a -> b) -> b -> RuleVar a -> b

foldl' :: (b -> a -> b) -> b -> RuleVar a -> b

foldr1 :: (a -> a -> a) -> RuleVar a -> a

foldl1 :: (a -> a -> a) -> RuleVar a -> a

toList :: RuleVar a -> [a]

null :: RuleVar a -> Bool

length :: RuleVar a -> Int

elem :: Eq a => a -> RuleVar a -> Bool

maximum :: Ord a => RuleVar a -> a

minimum :: Ord a => RuleVar a -> a

sum :: Num a => RuleVar a -> a

product :: Num a => RuleVar a -> a

Foldable Rule

Methods

fold :: Monoid m => Rule m -> m

foldMap :: Monoid m => (a -> m) -> Rule a -> m

foldr :: (a -> b -> b) -> b -> Rule a -> b

foldr' :: (a -> b -> b) -> b -> Rule a -> b

foldl :: (b -> a -> b) -> b -> Rule a -> b

foldl' :: (b -> a -> b) -> b -> Rule a -> b

foldr1 :: (a -> a -> a) -> Rule a -> a

foldl1 :: (a -> a -> a) -> Rule a -> a

toList :: Rule a -> [a]

null :: Rule a -> Bool

length :: Rule a -> Int

elem :: Eq a => a -> Rule a -> Bool

maximum :: Ord a => Rule a -> a

minimum :: Ord a => Rule a -> a

sum :: Num a => Rule a -> a

product :: Num a => Rule a -> a

Foldable Activation

Methods

fold :: Monoid m => Activation m -> m

foldMap :: Monoid m => (a -> m) -> Activation a -> m

foldr :: (a -> b -> b) -> b -> Activation a -> b

foldr' :: (a -> b -> b) -> b -> Activation a -> b

foldl :: (b -> a -> b) -> b -> Activation a -> b

foldl' :: (b -> a -> b) -> b -> Activation a -> b

foldr1 :: (a -> a -> a) -> Activation a -> a

foldl1 :: (a -> a -> a) -> Activation a -> a

toList :: Activation a -> [a]

null :: Activation a -> Bool

length :: Activation a -> Int

elem :: Eq a => a -> Activation a -> Bool

maximum :: Ord a => Activation a -> a

minimum :: Ord a => Activation a -> a

sum :: Num a => Activation a -> a

product :: Num a => Activation a -> a

Foldable Overlap

Methods

fold :: Monoid m => Overlap m -> m

foldMap :: Monoid m => (a -> m) -> Overlap a -> m

foldr :: (a -> b -> b) -> b -> Overlap a -> b

foldr' :: (a -> b -> b) -> b -> Overlap a -> b

foldl :: (b -> a -> b) -> b -> Overlap a -> b

foldl' :: (b -> a -> b) -> b -> Overlap a -> b

foldr1 :: (a -> a -> a) -> Overlap a -> a

foldl1 :: (a -> a -> a) -> Overlap a -> a

toList :: Overlap a -> [a]

null :: Overlap a -> Bool

length :: Overlap a -> Int

elem :: Eq a => a -> Overlap a -> Bool

maximum :: Ord a => Overlap a -> a

minimum :: Ord a => Overlap a -> a

sum :: Num a => Overlap a -> a

product :: Num a => Overlap a -> a

Foldable ModulePragma

Methods

fold :: Monoid m => ModulePragma m -> m

foldMap :: Monoid m => (a -> m) -> ModulePragma a -> m

foldr :: (a -> b -> b) -> b -> ModulePragma a -> b

foldr' :: (a -> b -> b) -> b -> ModulePragma a -> b

foldl :: (b -> a -> b) -> b -> ModulePragma a -> b

foldl' :: (b -> a -> b) -> b -> ModulePragma a -> b

foldr1 :: (a -> a -> a) -> ModulePragma a -> a

foldl1 :: (a -> a -> a) -> ModulePragma a -> a

toList :: ModulePragma a -> [a]

null :: ModulePragma a -> Bool

length :: ModulePragma a -> Int

elem :: Eq a => a -> ModulePragma a -> Bool

maximum :: Ord a => ModulePragma a -> a

minimum :: Ord a => ModulePragma a -> a

sum :: Num a => ModulePragma a -> a

product :: Num a => ModulePragma a -> a

Foldable CallConv

Methods

fold :: Monoid m => CallConv m -> m

foldMap :: Monoid m => (a -> m) -> CallConv a -> m

foldr :: (a -> b -> b) -> b -> CallConv a -> b

foldr' :: (a -> b -> b) -> b -> CallConv a -> b

foldl :: (b -> a -> b) -> b -> CallConv a -> b

foldl' :: (b -> a -> b) -> b -> CallConv a -> b

foldr1 :: (a -> a -> a) -> CallConv a -> a

foldl1 :: (a -> a -> a) -> CallConv a -> a

toList :: CallConv a -> [a]

null :: CallConv a -> Bool

length :: CallConv a -> Int

elem :: Eq a => a -> CallConv a -> Bool

maximum :: Ord a => CallConv a -> a

minimum :: Ord a => CallConv a -> a

sum :: Num a => CallConv a -> a

product :: Num a => CallConv a -> a

Foldable Safety

Methods

fold :: Monoid m => Safety m -> m

foldMap :: Monoid m => (a -> m) -> Safety a -> m

foldr :: (a -> b -> b) -> b -> Safety a -> b

foldr' :: (a -> b -> b) -> b -> Safety a -> b

foldl :: (b -> a -> b) -> b -> Safety a -> b

foldl' :: (b -> a -> b) -> b -> Safety a -> b

foldr1 :: (a -> a -> a) -> Safety a -> a

foldl1 :: (a -> a -> a) -> Safety a -> a

toList :: Safety a -> [a]

null :: Safety a -> Bool

length :: Safety a -> Int

elem :: Eq a => a -> Safety a -> Bool

maximum :: Ord a => Safety a -> a

minimum :: Ord a => Safety a -> a

sum :: Num a => Safety a -> a

product :: Num a => Safety a -> a

Foldable Splice

Methods

fold :: Monoid m => Splice m -> m

foldMap :: Monoid m => (a -> m) -> Splice a -> m

foldr :: (a -> b -> b) -> b -> Splice a -> b

foldr' :: (a -> b -> b) -> b -> Splice a -> b

foldl :: (b -> a -> b) -> b -> Splice a -> b

foldl' :: (b -> a -> b) -> b -> Splice a -> b

foldr1 :: (a -> a -> a) -> Splice a -> a

foldl1 :: (a -> a -> a) -> Splice a -> a

toList :: Splice a -> [a]

null :: Splice a -> Bool

length :: Splice a -> Int

elem :: Eq a => a -> Splice a -> Bool

maximum :: Ord a => Splice a -> a

minimum :: Ord a => Splice a -> a

sum :: Num a => Splice a -> a

product :: Num a => Splice a -> a

Foldable Bracket

Methods

fold :: Monoid m => Bracket m -> m

foldMap :: Monoid m => (a -> m) -> Bracket a -> m

foldr :: (a -> b -> b) -> b -> Bracket a -> b

foldr' :: (a -> b -> b) -> b -> Bracket a -> b

foldl :: (b -> a -> b) -> b -> Bracket a -> b

foldl' :: (b -> a -> b) -> b -> Bracket a -> b

foldr1 :: (a -> a -> a) -> Bracket a -> a

foldl1 :: (a -> a -> a) -> Bracket a -> a

toList :: Bracket a -> [a]

null :: Bracket a -> Bool

length :: Bracket a -> Int

elem :: Eq a => a -> Bracket a -> Bool

maximum :: Ord a => Bracket a -> a

minimum :: Ord a => Bracket a -> a

sum :: Num a => Bracket a -> a

product :: Num a => Bracket a -> a

Foldable XAttr

Methods

fold :: Monoid m => XAttr m -> m

foldMap :: Monoid m => (a -> m) -> XAttr a -> m

foldr :: (a -> b -> b) -> b -> XAttr a -> b

foldr' :: (a -> b -> b) -> b -> XAttr a -> b

foldl :: (b -> a -> b) -> b -> XAttr a -> b

foldl' :: (b -> a -> b) -> b -> XAttr a -> b

foldr1 :: (a -> a -> a) -> XAttr a -> a

foldl1 :: (a -> a -> a) -> XAttr a -> a

toList :: XAttr a -> [a]

null :: XAttr a -> Bool

length :: XAttr a -> Int

elem :: Eq a => a -> XAttr a -> Bool

maximum :: Ord a => XAttr a -> a

minimum :: Ord a => XAttr a -> a

sum :: Num a => XAttr a -> a

product :: Num a => XAttr a -> a

Foldable XName

Methods

fold :: Monoid m => XName m -> m

foldMap :: Monoid m => (a -> m) -> XName a -> m

foldr :: (a -> b -> b) -> b -> XName a -> b

foldr' :: (a -> b -> b) -> b -> XName a -> b

foldl :: (b -> a -> b) -> b -> XName a -> b

foldl' :: (b -> a -> b) -> b -> XName a -> b

foldr1 :: (a -> a -> a) -> XName a -> a

foldl1 :: (a -> a -> a) -> XName a -> a

toList :: XName a -> [a]

null :: XName a -> Bool

length :: XName a -> Int

elem :: Eq a => a -> XName a -> Bool

maximum :: Ord a => XName a -> a

minimum :: Ord a => XName a -> a

sum :: Num a => XName a -> a

product :: Num a => XName a -> a

Foldable Exp

Methods

fold :: Monoid m => Exp m -> m

foldMap :: Monoid m => (a -> m) -> Exp a -> m

foldr :: (a -> b -> b) -> b -> Exp a -> b

foldr' :: (a -> b -> b) -> b -> Exp a -> b

foldl :: (b -> a -> b) -> b -> Exp a -> b

foldl' :: (b -> a -> b) -> b -> Exp a -> b

foldr1 :: (a -> a -> a) -> Exp a -> a

foldl1 :: (a -> a -> a) -> Exp a -> a

toList :: Exp a -> [a]

null :: Exp a -> Bool

length :: Exp a -> Int

elem :: Eq a => a -> Exp a -> Bool

maximum :: Ord a => Exp a -> a

minimum :: Ord a => Exp a -> a

sum :: Num a => Exp a -> a

product :: Num a => Exp a -> a

Foldable Sign

Methods

fold :: Monoid m => Sign m -> m

foldMap :: Monoid m => (a -> m) -> Sign a -> m

foldr :: (a -> b -> b) -> b -> Sign a -> b

foldr' :: (a -> b -> b) -> b -> Sign a -> b

foldl :: (b -> a -> b) -> b -> Sign a -> b

foldl' :: (b -> a -> b) -> b -> Sign a -> b

foldr1 :: (a -> a -> a) -> Sign a -> a

foldl1 :: (a -> a -> a) -> Sign a -> a

toList :: Sign a -> [a]

null :: Sign a -> Bool

length :: Sign a -> Int

elem :: Eq a => a -> Sign a -> Bool

maximum :: Ord a => Sign a -> a

minimum :: Ord a => Sign a -> a

sum :: Num a => Sign a -> a

product :: Num a => Sign a -> a

Foldable Literal

Methods

fold :: Monoid m => Literal m -> m

foldMap :: Monoid m => (a -> m) -> Literal a -> m

foldr :: (a -> b -> b) -> b -> Literal a -> b

foldr' :: (a -> b -> b) -> b -> Literal a -> b

foldl :: (b -> a -> b) -> b -> Literal a -> b

foldl' :: (b -> a -> b) -> b -> Literal a -> b

foldr1 :: (a -> a -> a) -> Literal a -> a

foldl1 :: (a -> a -> a) -> Literal a -> a

toList :: Literal a -> [a]

null :: Literal a -> Bool

length :: Literal a -> Int

elem :: Eq a => a -> Literal a -> Bool

maximum :: Ord a => Literal a -> a

minimum :: Ord a => Literal a -> a

sum :: Num a => Literal a -> a

product :: Num a => Literal a -> a

Foldable Asst

Methods

fold :: Monoid m => Asst m -> m

foldMap :: Monoid m => (a -> m) -> Asst a -> m

foldr :: (a -> b -> b) -> b -> Asst a -> b

foldr' :: (a -> b -> b) -> b -> Asst a -> b

foldl :: (b -> a -> b) -> b -> Asst a -> b

foldl' :: (b -> a -> b) -> b -> Asst a -> b

foldr1 :: (a -> a -> a) -> Asst a -> a

foldl1 :: (a -> a -> a) -> Asst a -> a

toList :: Asst a -> [a]

null :: Asst a -> Bool

length :: Asst a -> Int

elem :: Eq a => a -> Asst a -> Bool

maximum :: Ord a => Asst a -> a

minimum :: Ord a => Asst a -> a

sum :: Num a => Asst a -> a

product :: Num a => Asst a -> a

Foldable Context

Methods

fold :: Monoid m => Context m -> m

foldMap :: Monoid m => (a -> m) -> Context a -> m

foldr :: (a -> b -> b) -> b -> Context a -> b

foldr' :: (a -> b -> b) -> b -> Context a -> b

foldl :: (b -> a -> b) -> b -> Context a -> b

foldl' :: (b -> a -> b) -> b -> Context a -> b

foldr1 :: (a -> a -> a) -> Context a -> a

foldl1 :: (a -> a -> a) -> Context a -> a

toList :: Context a -> [a]

null :: Context a -> Bool

length :: Context a -> Int

elem :: Eq a => a -> Context a -> Bool

maximum :: Ord a => Context a -> a

minimum :: Ord a => Context a -> a

sum :: Num a => Context a -> a

product :: Num a => Context a -> a

Foldable FunDep

Methods

fold :: Monoid m => FunDep m -> m

foldMap :: Monoid m => (a -> m) -> FunDep a -> m

foldr :: (a -> b -> b) -> b -> FunDep a -> b

foldr' :: (a -> b -> b) -> b -> FunDep a -> b

foldl :: (b -> a -> b) -> b -> FunDep a -> b

foldl' :: (b -> a -> b) -> b -> FunDep a -> b

foldr1 :: (a -> a -> a) -> FunDep a -> a

foldl1 :: (a -> a -> a) -> FunDep a -> a

toList :: FunDep a -> [a]

null :: FunDep a -> Bool

length :: FunDep a -> Int

elem :: Eq a => a -> FunDep a -> Bool

maximum :: Ord a => FunDep a -> a

minimum :: Ord a => FunDep a -> a

sum :: Num a => FunDep a -> a

product :: Num a => FunDep a -> a

Foldable Kind

Methods

fold :: Monoid m => Kind m -> m

foldMap :: Monoid m => (a -> m) -> Kind a -> m

foldr :: (a -> b -> b) -> b -> Kind a -> b

foldr' :: (a -> b -> b) -> b -> Kind a -> b

foldl :: (b -> a -> b) -> b -> Kind a -> b

foldl' :: (b -> a -> b) -> b -> Kind a -> b

foldr1 :: (a -> a -> a) -> Kind a -> a

foldl1 :: (a -> a -> a) -> Kind a -> a

toList :: Kind a -> [a]

null :: Kind a -> Bool

length :: Kind a -> Int

elem :: Eq a => a -> Kind a -> Bool

maximum :: Ord a => Kind a -> a

minimum :: Ord a => Kind a -> a

sum :: Num a => Kind a -> a

product :: Num a => Kind a -> a

Foldable TyVarBind

Methods

fold :: Monoid m => TyVarBind m -> m

foldMap :: Monoid m => (a -> m) -> TyVarBind a -> m

foldr :: (a -> b -> b) -> b -> TyVarBind a -> b

foldr' :: (a -> b -> b) -> b -> TyVarBind a -> b

foldl :: (b -> a -> b) -> b -> TyVarBind a -> b

foldl' :: (b -> a -> b) -> b -> TyVarBind a -> b

foldr1 :: (a -> a -> a) -> TyVarBind a -> a

foldl1 :: (a -> a -> a) -> TyVarBind a -> a

toList :: TyVarBind a -> [a]

null :: TyVarBind a -> Bool

length :: TyVarBind a -> Int

elem :: Eq a => a -> TyVarBind a -> Bool

maximum :: Ord a => TyVarBind a -> a

minimum :: Ord a => TyVarBind a -> a

sum :: Num a => TyVarBind a -> a

product :: Num a => TyVarBind a -> a

Foldable Promoted

Methods

fold :: Monoid m => Promoted m -> m

foldMap :: Monoid m => (a -> m) -> Promoted a -> m

foldr :: (a -> b -> b) -> b -> Promoted a -> b

foldr' :: (a -> b -> b) -> b -> Promoted a -> b

foldl :: (b -> a -> b) -> b -> Promoted a -> b

foldl' :: (b -> a -> b) -> b -> Promoted a -> b

foldr1 :: (a -> a -> a) -> Promoted a -> a

foldl1 :: (a -> a -> a) -> Promoted a -> a

toList :: Promoted a -> [a]

null :: Promoted a -> Bool

length :: Promoted a -> Int

elem :: Eq a => a -> Promoted a -> Bool

maximum :: Ord a => Promoted a -> a

minimum :: Ord a => Promoted a -> a

sum :: Num a => Promoted a -> a

product :: Num a => Promoted a -> a

Foldable Type

Methods

fold :: Monoid m => Type m -> m

foldMap :: Monoid m => (a -> m) -> Type a -> m

foldr :: (a -> b -> b) -> b -> Type a -> b

foldr' :: (a -> b -> b) -> b -> Type a -> b

foldl :: (b -> a -> b) -> b -> Type a -> b

foldl' :: (b -> a -> b) -> b -> Type a -> b

foldr1 :: (a -> a -> a) -> Type a -> a

foldl1 :: (a -> a -> a) -> Type a -> a

toList :: Type a -> [a]

null :: Type a -> Bool

length :: Type a -> Int

elem :: Eq a => a -> Type a -> Bool

maximum :: Ord a => Type a -> a

minimum :: Ord a => Type a -> a

sum :: Num a => Type a -> a

product :: Num a => Type a -> a

Foldable GuardedRhs

Methods

fold :: Monoid m => GuardedRhs m -> m

foldMap :: Monoid m => (a -> m) -> GuardedRhs a -> m

foldr :: (a -> b -> b) -> b -> GuardedRhs a -> b

foldr' :: (a -> b -> b) -> b -> GuardedRhs a -> b

foldl :: (b -> a -> b) -> b -> GuardedRhs a -> b

foldl' :: (b -> a -> b) -> b -> GuardedRhs a -> b

foldr1 :: (a -> a -> a) -> GuardedRhs a -> a

foldl1 :: (a -> a -> a) -> GuardedRhs a -> a

toList :: GuardedRhs a -> [a]

null :: GuardedRhs a -> Bool

length :: GuardedRhs a -> Int

elem :: Eq a => a -> GuardedRhs a -> Bool

maximum :: Ord a => GuardedRhs a -> a

minimum :: Ord a => GuardedRhs a -> a

sum :: Num a => GuardedRhs a -> a

product :: Num a => GuardedRhs a -> a

Foldable Rhs

Methods

fold :: Monoid m => Rhs m -> m

foldMap :: Monoid m => (a -> m) -> Rhs a -> m

foldr :: (a -> b -> b) -> b -> Rhs a -> b

foldr' :: (a -> b -> b) -> b -> Rhs a -> b

foldl :: (b -> a -> b) -> b -> Rhs a -> b

foldl' :: (b -> a -> b) -> b -> Rhs a -> b

foldr1 :: (a -> a -> a) -> Rhs a -> a

foldl1 :: (a -> a -> a) -> Rhs a -> a

toList :: Rhs a -> [a]

null :: Rhs a -> Bool

length :: Rhs a -> Int

elem :: Eq a => a -> Rhs a -> Bool

maximum :: Ord a => Rhs a -> a

minimum :: Ord a => Rhs a -> a

sum :: Num a => Rhs a -> a

product :: Num a => Rhs a -> a

Foldable Unpackedness

Methods

fold :: Monoid m => Unpackedness m -> m

foldMap :: Monoid m => (a -> m) -> Unpackedness a -> m

foldr :: (a -> b -> b) -> b -> Unpackedness a -> b

foldr' :: (a -> b -> b) -> b -> Unpackedness a -> b

foldl :: (b -> a -> b) -> b -> Unpackedness a -> b

foldl' :: (b -> a -> b) -> b -> Unpackedness a -> b

foldr1 :: (a -> a -> a) -> Unpackedness a -> a

foldl1 :: (a -> a -> a) -> Unpackedness a -> a

toList :: Unpackedness a -> [a]

null :: Unpackedness a -> Bool

length :: Unpackedness a -> Int

elem :: Eq a => a -> Unpackedness a -> Bool

maximum :: Ord a => Unpackedness a -> a

minimum :: Ord a => Unpackedness a -> a

sum :: Num a => Unpackedness a -> a

product :: Num a => Unpackedness a -> a

Foldable BangType

Methods

fold :: Monoid m => BangType m -> m

foldMap :: Monoid m => (a -> m) -> BangType a -> m

foldr :: (a -> b -> b) -> b -> BangType a -> b

foldr' :: (a -> b -> b) -> b -> BangType a -> b

foldl :: (b -> a -> b) -> b -> BangType a -> b

foldl' :: (b -> a -> b) -> b -> BangType a -> b

foldr1 :: (a -> a -> a) -> BangType a -> a

foldl1 :: (a -> a -> a) -> BangType a -> a

toList :: BangType a -> [a]

null :: BangType a -> Bool

length :: BangType a -> Int

elem :: Eq a => a -> BangType a -> Bool

maximum :: Ord a => BangType a -> a

minimum :: Ord a => BangType a -> a

sum :: Num a => BangType a -> a

product :: Num a => BangType a -> a

Foldable InstDecl

Methods

fold :: Monoid m => InstDecl m -> m

foldMap :: Monoid m => (a -> m) -> InstDecl a -> m

foldr :: (a -> b -> b) -> b -> InstDecl a -> b

foldr' :: (a -> b -> b) -> b -> InstDecl a -> b

foldl :: (b -> a -> b) -> b -> InstDecl a -> b

foldl' :: (b -> a -> b) -> b -> InstDecl a -> b

foldr1 :: (a -> a -> a) -> InstDecl a -> a

foldl1 :: (a -> a -> a) -> InstDecl a -> a

toList :: InstDecl a -> [a]

null :: InstDecl a -> Bool

length :: InstDecl a -> Int

elem :: Eq a => a -> InstDecl a -> Bool

maximum :: Ord a => InstDecl a -> a

minimum :: Ord a => InstDecl a -> a

sum :: Num a => InstDecl a -> a

product :: Num a => InstDecl a -> a

Foldable ClassDecl

Methods

fold :: Monoid m => ClassDecl m -> m

foldMap :: Monoid m => (a -> m) -> ClassDecl a -> m

foldr :: (a -> b -> b) -> b -> ClassDecl a -> b

foldr' :: (a -> b -> b) -> b -> ClassDecl a -> b

foldl :: (b -> a -> b) -> b -> ClassDecl a -> b

foldl' :: (b -> a -> b) -> b -> ClassDecl a -> b

foldr1 :: (a -> a -> a) -> ClassDecl a -> a

foldl1 :: (a -> a -> a) -> ClassDecl a -> a

toList :: ClassDecl a -> [a]

null :: ClassDecl a -> Bool

length :: ClassDecl a -> Int

elem :: Eq a => a -> ClassDecl a -> Bool

maximum :: Ord a => ClassDecl a -> a

minimum :: Ord a => ClassDecl a -> a

sum :: Num a => ClassDecl a -> a

product :: Num a => ClassDecl a -> a

Foldable GadtDecl

Methods

fold :: Monoid m => GadtDecl m -> m

foldMap :: Monoid m => (a -> m) -> GadtDecl a -> m

foldr :: (a -> b -> b) -> b -> GadtDecl a -> b

foldr' :: (a -> b -> b) -> b -> GadtDecl a -> b

foldl :: (b -> a -> b) -> b -> GadtDecl a -> b

foldl' :: (b -> a -> b) -> b -> GadtDecl a -> b

foldr1 :: (a -> a -> a) -> GadtDecl a -> a

foldl1 :: (a -> a -> a) -> GadtDecl a -> a

toList :: GadtDecl a -> [a]

null :: GadtDecl a -> Bool

length :: GadtDecl a -> Int

elem :: Eq a => a -> GadtDecl a -> Bool

maximum :: Ord a => GadtDecl a -> a

minimum :: Ord a => GadtDecl a -> a

sum :: Num a => GadtDecl a -> a

product :: Num a => GadtDecl a -> a

Foldable ConDecl

Methods

fold :: Monoid m => ConDecl m -> m

foldMap :: Monoid m => (a -> m) -> ConDecl a -> m

foldr :: (a -> b -> b) -> b -> ConDecl a -> b

foldr' :: (a -> b -> b) -> b -> ConDecl a -> b

foldl :: (b -> a -> b) -> b -> ConDecl a -> b

foldl' :: (b -> a -> b) -> b -> ConDecl a -> b

foldr1 :: (a -> a -> a) -> ConDecl a -> a

foldl1 :: (a -> a -> a) -> ConDecl a -> a

toList :: ConDecl a -> [a]

null :: ConDecl a -> Bool

length :: ConDecl a -> Int

elem :: Eq a => a -> ConDecl a -> Bool

maximum :: Ord a => ConDecl a -> a

minimum :: Ord a => ConDecl a -> a

sum :: Num a => ConDecl a -> a

product :: Num a => ConDecl a -> a

Foldable QualConDecl

Methods

fold :: Monoid m => QualConDecl m -> m

foldMap :: Monoid m => (a -> m) -> QualConDecl a -> m

foldr :: (a -> b -> b) -> b -> QualConDecl a -> b

foldr' :: (a -> b -> b) -> b -> QualConDecl a -> b

foldl :: (b -> a -> b) -> b -> QualConDecl a -> b

foldl' :: (b -> a -> b) -> b -> QualConDecl a -> b

foldr1 :: (a -> a -> a) -> QualConDecl a -> a

foldl1 :: (a -> a -> a) -> QualConDecl a -> a

toList :: QualConDecl a -> [a]

null :: QualConDecl a -> Bool

length :: QualConDecl a -> Int

elem :: Eq a => a -> QualConDecl a -> Bool

maximum :: Ord a => QualConDecl a -> a

minimum :: Ord a => QualConDecl a -> a

sum :: Num a => QualConDecl a -> a

product :: Num a => QualConDecl a -> a

Foldable Match

Methods

fold :: Monoid m => Match m -> m

foldMap :: Monoid m => (a -> m) -> Match a -> m

foldr :: (a -> b -> b) -> b -> Match a -> b

foldr' :: (a -> b -> b) -> b -> Match a -> b

foldl :: (b -> a -> b) -> b -> Match a -> b

foldl' :: (b -> a -> b) -> b -> Match a -> b

foldr1 :: (a -> a -> a) -> Match a -> a

foldl1 :: (a -> a -> a) -> Match a -> a

toList :: Match a -> [a]

null :: Match a -> Bool

length :: Match a -> Int

elem :: Eq a => a -> Match a -> Bool

maximum :: Ord a => Match a -> a

minimum :: Ord a => Match a -> a

sum :: Num a => Match a -> a

product :: Num a => Match a -> a

Foldable IPBind

Methods

fold :: Monoid m => IPBind m -> m

foldMap :: Monoid m => (a -> m) -> IPBind a -> m

foldr :: (a -> b -> b) -> b -> IPBind a -> b

foldr' :: (a -> b -> b) -> b -> IPBind a -> b

foldl :: (b -> a -> b) -> b -> IPBind a -> b

foldl' :: (b -> a -> b) -> b -> IPBind a -> b

foldr1 :: (a -> a -> a) -> IPBind a -> a

foldl1 :: (a -> a -> a) -> IPBind a -> a

toList :: IPBind a -> [a]

null :: IPBind a -> Bool

length :: IPBind a -> Int

elem :: Eq a => a -> IPBind a -> Bool

maximum :: Ord a => IPBind a -> a

minimum :: Ord a => IPBind a -> a

sum :: Num a => IPBind a -> a

product :: Num a => IPBind a -> a

Foldable Binds

Methods

fold :: Monoid m => Binds m -> m

foldMap :: Monoid m => (a -> m) -> Binds a -> m

foldr :: (a -> b -> b) -> b -> Binds a -> b

foldr' :: (a -> b -> b) -> b -> Binds a -> b

foldl :: (b -> a -> b) -> b -> Binds a -> b

foldl' :: (b -> a -> b) -> b -> Binds a -> b

foldr1 :: (a -> a -> a) -> Binds a -> a

foldl1 :: (a -> a -> a) -> Binds a -> a

toList :: Binds a -> [a]

null :: Binds a -> Bool

length :: Binds a -> Int

elem :: Eq a => a -> Binds a -> Bool

maximum :: Ord a => Binds a -> a

minimum :: Ord a => Binds a -> a

sum :: Num a => Binds a -> a

product :: Num a => Binds a -> a

Foldable Deriving

Methods

fold :: Monoid m => Deriving m -> m

foldMap :: Monoid m => (a -> m) -> Deriving a -> m

foldr :: (a -> b -> b) -> b -> Deriving a -> b

foldr' :: (a -> b -> b) -> b -> Deriving a -> b

foldl :: (b -> a -> b) -> b -> Deriving a -> b

foldl' :: (b -> a -> b) -> b -> Deriving a -> b

foldr1 :: (a -> a -> a) -> Deriving a -> a

foldl1 :: (a -> a -> a) -> Deriving a -> a

toList :: Deriving a -> [a]

null :: Deriving a -> Bool

length :: Deriving a -> Int

elem :: Eq a => a -> Deriving a -> Bool

maximum :: Ord a => Deriving a -> a

minimum :: Ord a => Deriving a -> a

sum :: Num a => Deriving a -> a

product :: Num a => Deriving a -> a

Foldable InstHead

Methods

fold :: Monoid m => InstHead m -> m

foldMap :: Monoid m => (a -> m) -> InstHead a -> m

foldr :: (a -> b -> b) -> b -> InstHead a -> b

foldr' :: (a -> b -> b) -> b -> InstHead a -> b

foldl :: (b -> a -> b) -> b -> InstHead a -> b

foldl' :: (b -> a -> b) -> b -> InstHead a -> b

foldr1 :: (a -> a -> a) -> InstHead a -> a

foldl1 :: (a -> a -> a) -> InstHead a -> a

toList :: InstHead a -> [a]

null :: InstHead a -> Bool

length :: InstHead a -> Int

elem :: Eq a => a -> InstHead a -> Bool

maximum :: Ord a => InstHead a -> a

minimum :: Ord a => InstHead a -> a

sum :: Num a => InstHead a -> a

product :: Num a => InstHead a -> a

Foldable InstRule

Methods

fold :: Monoid m => InstRule m -> m

foldMap :: Monoid m => (a -> m) -> InstRule a -> m

foldr :: (a -> b -> b) -> b -> InstRule a -> b

foldr' :: (a -> b -> b) -> b -> InstRule a -> b

foldl :: (b -> a -> b) -> b -> InstRule a -> b

foldl' :: (b -> a -> b) -> b -> InstRule a -> b

foldr1 :: (a -> a -> a) -> InstRule a -> a

foldl1 :: (a -> a -> a) -> InstRule a -> a

toList :: InstRule a -> [a]

null :: InstRule a -> Bool

length :: InstRule a -> Int

elem :: Eq a => a -> InstRule a -> Bool

maximum :: Ord a => InstRule a -> a

minimum :: Ord a => InstRule a -> a

sum :: Num a => InstRule a -> a

product :: Num a => InstRule a -> a

Foldable DeclHead

Methods

fold :: Monoid m => DeclHead m -> m

foldMap :: Monoid m => (a -> m) -> DeclHead a -> m

foldr :: (a -> b -> b) -> b -> DeclHead a -> b

foldr' :: (a -> b -> b) -> b -> DeclHead a -> b

foldl :: (b -> a -> b) -> b -> DeclHead a -> b

foldl' :: (b -> a -> b) -> b -> DeclHead a -> b

foldr1 :: (a -> a -> a) -> DeclHead a -> a

foldl1 :: (a -> a -> a) -> DeclHead a -> a

toList :: DeclHead a -> [a]

null :: DeclHead a -> Bool

length :: DeclHead a -> Int

elem :: Eq a => a -> DeclHead a -> Bool

maximum :: Ord a => DeclHead a -> a

minimum :: Ord a => DeclHead a -> a

sum :: Num a => DeclHead a -> a

product :: Num a => DeclHead a -> a

Foldable ResultSig

Methods

fold :: Monoid m => ResultSig m -> m

foldMap :: Monoid m => (a -> m) -> ResultSig a -> m

foldr :: (a -> b -> b) -> b -> ResultSig a -> b

foldr' :: (a -> b -> b) -> b -> ResultSig a -> b

foldl :: (b -> a -> b) -> b -> ResultSig a -> b

foldl' :: (b -> a -> b) -> b -> ResultSig a -> b

foldr1 :: (a -> a -> a) -> ResultSig a -> a

foldl1 :: (a -> a -> a) -> ResultSig a -> a

toList :: ResultSig a -> [a]

null :: ResultSig a -> Bool

length :: ResultSig a -> Int

elem :: Eq a => a -> ResultSig a -> Bool

maximum :: Ord a => ResultSig a -> a

minimum :: Ord a => ResultSig a -> a

sum :: Num a => ResultSig a -> a

product :: Num a => ResultSig a -> a

Foldable InjectivityInfo

Methods

fold :: Monoid m => InjectivityInfo m -> m

foldMap :: Monoid m => (a -> m) -> InjectivityInfo a -> m

foldr :: (a -> b -> b) -> b -> InjectivityInfo a -> b

foldr' :: (a -> b -> b) -> b -> InjectivityInfo a -> b

foldl :: (b -> a -> b) -> b -> InjectivityInfo a -> b

foldl' :: (b -> a -> b) -> b -> InjectivityInfo a -> b

foldr1 :: (a -> a -> a) -> InjectivityInfo a -> a

foldl1 :: (a -> a -> a) -> InjectivityInfo a -> a

toList :: InjectivityInfo a -> [a]

null :: InjectivityInfo a -> Bool

length :: InjectivityInfo a -> Int

elem :: Eq a => a -> InjectivityInfo a -> Bool

maximum :: Ord a => InjectivityInfo a -> a

minimum :: Ord a => InjectivityInfo a -> a

sum :: Num a => InjectivityInfo a -> a

product :: Num a => InjectivityInfo a -> a

Foldable DataOrNew

Methods

fold :: Monoid m => DataOrNew m -> m

foldMap :: Monoid m => (a -> m) -> DataOrNew a -> m

foldr :: (a -> b -> b) -> b -> DataOrNew a -> b

foldr' :: (a -> b -> b) -> b -> DataOrNew a -> b

foldl :: (b -> a -> b) -> b -> DataOrNew a -> b

foldl' :: (b -> a -> b) -> b -> DataOrNew a -> b

foldr1 :: (a -> a -> a) -> DataOrNew a -> a

foldl1 :: (a -> a -> a) -> DataOrNew a -> a

toList :: DataOrNew a -> [a]

null :: DataOrNew a -> Bool

length :: DataOrNew a -> Int

elem :: Eq a => a -> DataOrNew a -> Bool

maximum :: Ord a => DataOrNew a -> a

minimum :: Ord a => DataOrNew a -> a

sum :: Num a => DataOrNew a -> a

product :: Num a => DataOrNew a -> a

Foldable Role

Methods

fold :: Monoid m => Role m -> m

foldMap :: Monoid m => (a -> m) -> Role a -> m

foldr :: (a -> b -> b) -> b -> Role a -> b

foldr' :: (a -> b -> b) -> b -> Role a -> b

foldl :: (b -> a -> b) -> b -> Role a -> b

foldl' :: (b -> a -> b) -> b -> Role a -> b

foldr1 :: (a -> a -> a) -> Role a -> a

foldl1 :: (a -> a -> a) -> Role a -> a

toList :: Role a -> [a]

null :: Role a -> Bool

length :: Role a -> Int

elem :: Eq a => a -> Role a -> Bool

maximum :: Ord a => Role a -> a

minimum :: Ord a => Role a -> a

sum :: Num a => Role a -> a

product :: Num a => Role a -> a

Foldable BooleanFormula

Methods

fold :: Monoid m => BooleanFormula m -> m

foldMap :: Monoid m => (a -> m) -> BooleanFormula a -> m

foldr :: (a -> b -> b) -> b -> BooleanFormula a -> b

foldr' :: (a -> b -> b) -> b -> BooleanFormula a -> b

foldl :: (b -> a -> b) -> b -> BooleanFormula a -> b

foldl' :: (b -> a -> b) -> b -> BooleanFormula a -> b

foldr1 :: (a -> a -> a) -> BooleanFormula a -> a

foldl1 :: (a -> a -> a) -> BooleanFormula a -> a

toList :: BooleanFormula a -> [a]

null :: BooleanFormula a -> Bool

length :: BooleanFormula a -> Int

elem :: Eq a => a -> BooleanFormula a -> Bool

maximum :: Ord a => BooleanFormula a -> a

minimum :: Ord a => BooleanFormula a -> a

sum :: Num a => BooleanFormula a -> a

product :: Num a => BooleanFormula a -> a

Foldable Annotation

Methods

fold :: Monoid m => Annotation m -> m

foldMap :: Monoid m => (a -> m) -> Annotation a -> m

foldr :: (a -> b -> b) -> b -> Annotation a -> b

foldr' :: (a -> b -> b) -> b -> Annotation a -> b

foldl :: (b -> a -> b) -> b -> Annotation a -> b

foldl' :: (b -> a -> b) -> b -> Annotation a -> b

foldr1 :: (a -> a -> a) -> Annotation a -> a

foldl1 :: (a -> a -> a) -> Annotation a -> a

toList :: Annotation a -> [a]

null :: Annotation a -> Bool

length :: Annotation a -> Int

elem :: Eq a => a -> Annotation a -> Bool

maximum :: Ord a => Annotation a -> a

minimum :: Ord a => Annotation a -> a

sum :: Num a => Annotation a -> a

product :: Num a => Annotation a -> a

Foldable TypeEqn

Methods

fold :: Monoid m => TypeEqn m -> m

foldMap :: Monoid m => (a -> m) -> TypeEqn a -> m

foldr :: (a -> b -> b) -> b -> TypeEqn a -> b

foldr' :: (a -> b -> b) -> b -> TypeEqn a -> b

foldl :: (b -> a -> b) -> b -> TypeEqn a -> b

foldl' :: (b -> a -> b) -> b -> TypeEqn a -> b

foldr1 :: (a -> a -> a) -> TypeEqn a -> a

foldl1 :: (a -> a -> a) -> TypeEqn a -> a

toList :: TypeEqn a -> [a]

null :: TypeEqn a -> Bool

length :: TypeEqn a -> Int

elem :: Eq a => a -> TypeEqn a -> Bool

maximum :: Ord a => TypeEqn a -> a

minimum :: Ord a => TypeEqn a -> a

sum :: Num a => TypeEqn a -> a

product :: Num a => TypeEqn a -> a

Foldable PatternSynDirection

Methods

fold :: Monoid m => PatternSynDirection m -> m

foldMap :: Monoid m => (a -> m) -> PatternSynDirection a -> m

foldr :: (a -> b -> b) -> b -> PatternSynDirection a -> b

foldr' :: (a -> b -> b) -> b -> PatternSynDirection a -> b

foldl :: (b -> a -> b) -> b -> PatternSynDirection a -> b

foldl' :: (b -> a -> b) -> b -> PatternSynDirection a -> b

foldr1 :: (a -> a -> a) -> PatternSynDirection a -> a

foldl1 :: (a -> a -> a) -> PatternSynDirection a -> a

toList :: PatternSynDirection a -> [a]

null :: PatternSynDirection a -> Bool

length :: PatternSynDirection a -> Int

elem :: Eq a => a -> PatternSynDirection a -> Bool

maximum :: Ord a => PatternSynDirection a -> a

minimum :: Ord a => PatternSynDirection a -> a

sum :: Num a => PatternSynDirection a -> a

product :: Num a => PatternSynDirection a -> a

Foldable Decl

Methods

fold :: Monoid m => Decl m -> m

foldMap :: Monoid m => (a -> m) -> Decl a -> m

foldr :: (a -> b -> b) -> b -> Decl a -> b

foldr' :: (a -> b -> b) -> b -> Decl a -> b

foldl :: (b -> a -> b) -> b -> Decl a -> b

foldl' :: (b -> a -> b) -> b -> Decl a -> b

foldr1 :: (a -> a -> a) -> Decl a -> a

foldl1 :: (a -> a -> a) -> Decl a -> a

toList :: Decl a -> [a]

null :: Decl a -> Bool

length :: Decl a -> Int

elem :: Eq a => a -> Decl a -> Bool

maximum :: Ord a => Decl a -> a

minimum :: Ord a => Decl a -> a

sum :: Num a => Decl a -> a

product :: Num a => Decl a -> a

Foldable Assoc

Methods

fold :: Monoid m => Assoc m -> m

foldMap :: Monoid m => (a -> m) -> Assoc a -> m

foldr :: (a -> b -> b) -> b -> Assoc a -> b

foldr' :: (a -> b -> b) -> b -> Assoc a -> b

foldl :: (b -> a -> b) -> b -> Assoc a -> b

foldl' :: (b -> a -> b) -> b -> Assoc a -> b

foldr1 :: (a -> a -> a) -> Assoc a -> a

foldl1 :: (a -> a -> a) -> Assoc a -> a

toList :: Assoc a -> [a]

null :: Assoc a -> Bool

length :: Assoc a -> Int

elem :: Eq a => a -> Assoc a -> Bool

maximum :: Ord a => Assoc a -> a

minimum :: Ord a => Assoc a -> a

sum :: Num a => Assoc a -> a

product :: Num a => Assoc a -> a

Foldable ImportSpec

Methods

fold :: Monoid m => ImportSpec m -> m

foldMap :: Monoid m => (a -> m) -> ImportSpec a -> m

foldr :: (a -> b -> b) -> b -> ImportSpec a -> b

foldr' :: (a -> b -> b) -> b -> ImportSpec a -> b

foldl :: (b -> a -> b) -> b -> ImportSpec a -> b

foldl' :: (b -> a -> b) -> b -> ImportSpec a -> b

foldr1 :: (a -> a -> a) -> ImportSpec a -> a

foldl1 :: (a -> a -> a) -> ImportSpec a -> a

toList :: ImportSpec a -> [a]

null :: ImportSpec a -> Bool

length :: ImportSpec a -> Int

elem :: Eq a => a -> ImportSpec a -> Bool

maximum :: Ord a => ImportSpec a -> a

minimum :: Ord a => ImportSpec a -> a

sum :: Num a => ImportSpec a -> a

product :: Num a => ImportSpec a -> a

Foldable ImportSpecList

Methods

fold :: Monoid m => ImportSpecList m -> m

foldMap :: Monoid m => (a -> m) -> ImportSpecList a -> m

foldr :: (a -> b -> b) -> b -> ImportSpecList a -> b

foldr' :: (a -> b -> b) -> b -> ImportSpecList a -> b

foldl :: (b -> a -> b) -> b -> ImportSpecList a -> b

foldl' :: (b -> a -> b) -> b -> ImportSpecList a -> b

foldr1 :: (a -> a -> a) -> ImportSpecList a -> a

foldl1 :: (a -> a -> a) -> ImportSpecList a -> a

toList :: ImportSpecList a -> [a]

null :: ImportSpecList a -> Bool

length :: ImportSpecList a -> Int

elem :: Eq a => a -> ImportSpecList a -> Bool

maximum :: Ord a => ImportSpecList a -> a

minimum :: Ord a => ImportSpecList a -> a

sum :: Num a => ImportSpecList a -> a

product :: Num a => ImportSpecList a -> a

Foldable ImportDecl

Methods

fold :: Monoid m => ImportDecl m -> m

foldMap :: Monoid m => (a -> m) -> ImportDecl a -> m

foldr :: (a -> b -> b) -> b -> ImportDecl a -> b

foldr' :: (a -> b -> b) -> b -> ImportDecl a -> b

foldl :: (b -> a -> b) -> b -> ImportDecl a -> b

foldl' :: (b -> a -> b) -> b -> ImportDecl a -> b

foldr1 :: (a -> a -> a) -> ImportDecl a -> a

foldl1 :: (a -> a -> a) -> ImportDecl a -> a

toList :: ImportDecl a -> [a]

null :: ImportDecl a -> Bool

length :: ImportDecl a -> Int

elem :: Eq a => a -> ImportDecl a -> Bool

maximum :: Ord a => ImportDecl a -> a

minimum :: Ord a => ImportDecl a -> a

sum :: Num a => ImportDecl a -> a

product :: Num a => ImportDecl a -> a

Foldable Namespace

Methods

fold :: Monoid m => Namespace m -> m

foldMap :: Monoid m => (a -> m) -> Namespace a -> m

foldr :: (a -> b -> b) -> b -> Namespace a -> b

foldr' :: (a -> b -> b) -> b -> Namespace a -> b

foldl :: (b -> a -> b) -> b -> Namespace a -> b

foldl' :: (b -> a -> b) -> b -> Namespace a -> b

foldr1 :: (a -> a -> a) -> Namespace a -> a

foldl1 :: (a -> a -> a) -> Namespace a -> a

toList :: Namespace a -> [a]

null :: Namespace a -> Bool

length :: Namespace a -> Int

elem :: Eq a => a -> Namespace a -> Bool

maximum :: Ord a => Namespace a -> a

minimum :: Ord a => Namespace a -> a

sum :: Num a => Namespace a -> a

product :: Num a => Namespace a -> a

Foldable EWildcard

Methods

fold :: Monoid m => EWildcard m -> m

foldMap :: Monoid m => (a -> m) -> EWildcard a -> m

foldr :: (a -> b -> b) -> b -> EWildcard a -> b

foldr' :: (a -> b -> b) -> b -> EWildcard a -> b

foldl :: (b -> a -> b) -> b -> EWildcard a -> b

foldl' :: (b -> a -> b) -> b -> EWildcard a -> b

foldr1 :: (a -> a -> a) -> EWildcard a -> a

foldl1 :: (a -> a -> a) -> EWildcard a -> a

toList :: EWildcard a -> [a]

null :: EWildcard a -> Bool

length :: EWildcard a -> Int

elem :: Eq a => a -> EWildcard a -> Bool

maximum :: Ord a => EWildcard a -> a

minimum :: Ord a => EWildcard a -> a

sum :: Num a => EWildcard a -> a

product :: Num a => EWildcard a -> a

Foldable ExportSpec

Methods

fold :: Monoid m => ExportSpec m -> m

foldMap :: Monoid m => (a -> m) -> ExportSpec a -> m

foldr :: (a -> b -> b) -> b -> ExportSpec a -> b

foldr' :: (a -> b -> b) -> b -> ExportSpec a -> b

foldl :: (b -> a -> b) -> b -> ExportSpec a -> b

foldl' :: (b -> a -> b) -> b -> ExportSpec a -> b

foldr1 :: (a -> a -> a) -> ExportSpec a -> a

foldl1 :: (a -> a -> a) -> ExportSpec a -> a

toList :: ExportSpec a -> [a]

null :: ExportSpec a -> Bool

length :: ExportSpec a -> Int

elem :: Eq a => a -> ExportSpec a -> Bool

maximum :: Ord a => ExportSpec a -> a

minimum :: Ord a => ExportSpec a -> a

sum :: Num a => ExportSpec a -> a

product :: Num a => ExportSpec a -> a

Foldable ExportSpecList

Methods

fold :: Monoid m => ExportSpecList m -> m

foldMap :: Monoid m => (a -> m) -> ExportSpecList a -> m

foldr :: (a -> b -> b) -> b -> ExportSpecList a -> b

foldr' :: (a -> b -> b) -> b -> ExportSpecList a -> b

foldl :: (b -> a -> b) -> b -> ExportSpecList a -> b

foldl' :: (b -> a -> b) -> b -> ExportSpecList a -> b

foldr1 :: (a -> a -> a) -> ExportSpecList a -> a

foldl1 :: (a -> a -> a) -> ExportSpecList a -> a

toList :: ExportSpecList a -> [a]

null :: ExportSpecList a -> Bool

length :: ExportSpecList a -> Int

elem :: Eq a => a -> ExportSpecList a -> Bool

maximum :: Ord a => ExportSpecList a -> a

minimum :: Ord a => ExportSpecList a -> a

sum :: Num a => ExportSpecList a -> a

product :: Num a => ExportSpecList a -> a

Foldable ModuleHead

Methods

fold :: Monoid m => ModuleHead m -> m

foldMap :: Monoid m => (a -> m) -> ModuleHead a -> m

foldr :: (a -> b -> b) -> b -> ModuleHead a -> b

foldr' :: (a -> b -> b) -> b -> ModuleHead a -> b

foldl :: (b -> a -> b) -> b -> ModuleHead a -> b

foldl' :: (b -> a -> b) -> b -> ModuleHead a -> b

foldr1 :: (a -> a -> a) -> ModuleHead a -> a

foldl1 :: (a -> a -> a) -> ModuleHead a -> a

toList :: ModuleHead a -> [a]

null :: ModuleHead a -> Bool

length :: ModuleHead a -> Int

elem :: Eq a => a -> ModuleHead a -> Bool

maximum :: Ord a => ModuleHead a -> a

minimum :: Ord a => ModuleHead a -> a

sum :: Num a => ModuleHead a -> a

product :: Num a => ModuleHead a -> a

Foldable Module

Methods

fold :: Monoid m => Module m -> m

foldMap :: Monoid m => (a -> m) -> Module a -> m

foldr :: (a -> b -> b) -> b -> Module a -> b

foldr' :: (a -> b -> b) -> b -> Module a -> b

foldl :: (b -> a -> b) -> b -> Module a -> b

foldl' :: (b -> a -> b) -> b -> Module a -> b

foldr1 :: (a -> a -> a) -> Module a -> a

foldl1 :: (a -> a -> a) -> Module a -> a

toList :: Module a -> [a]

null :: Module a -> Bool

length :: Module a -> Int

elem :: Eq a => a -> Module a -> Bool

maximum :: Ord a => Module a -> a

minimum :: Ord a => Module a -> a

sum :: Num a => Module a -> a

product :: Num a => Module a -> a

Foldable CName

Methods

fold :: Monoid m => CName m -> m

foldMap :: Monoid m => (a -> m) -> CName a -> m

foldr :: (a -> b -> b) -> b -> CName a -> b

foldr' :: (a -> b -> b) -> b -> CName a -> b

foldl :: (b -> a -> b) -> b -> CName a -> b

foldl' :: (b -> a -> b) -> b -> CName a -> b

foldr1 :: (a -> a -> a) -> CName a -> a

foldl1 :: (a -> a -> a) -> CName a -> a

toList :: CName a -> [a]

null :: CName a -> Bool

length :: CName a -> Int

elem :: Eq a => a -> CName a -> Bool

maximum :: Ord a => CName a -> a

minimum :: Ord a => CName a -> a

sum :: Num a => CName a -> a

product :: Num a => CName a -> a

Foldable Op

Methods

fold :: Monoid m => Op m -> m

foldMap :: Monoid m => (a -> m) -> Op a -> m

foldr :: (a -> b -> b) -> b -> Op a -> b

foldr' :: (a -> b -> b) -> b -> Op a -> b

foldl :: (b -> a -> b) -> b -> Op a -> b

foldl' :: (b -> a -> b) -> b -> Op a -> b

foldr1 :: (a -> a -> a) -> Op a -> a

foldl1 :: (a -> a -> a) -> Op a -> a

toList :: Op a -> [a]

null :: Op a -> Bool

length :: Op a -> Int

elem :: Eq a => a -> Op a -> Bool

maximum :: Ord a => Op a -> a

minimum :: Ord a => Op a -> a

sum :: Num a => Op a -> a

product :: Num a => Op a -> a

Foldable QOp

Methods

fold :: Monoid m => QOp m -> m

foldMap :: Monoid m => (a -> m) -> QOp a -> m

foldr :: (a -> b -> b) -> b -> QOp a -> b

foldr' :: (a -> b -> b) -> b -> QOp a -> b

foldl :: (b -> a -> b) -> b -> QOp a -> b

foldl' :: (b -> a -> b) -> b -> QOp a -> b

foldr1 :: (a -> a -> a) -> QOp a -> a

foldl1 :: (a -> a -> a) -> QOp a -> a

toList :: QOp a -> [a]

null :: QOp a -> Bool

length :: QOp a -> Int

elem :: Eq a => a -> QOp a -> Bool

maximum :: Ord a => QOp a -> a

minimum :: Ord a => QOp a -> a

sum :: Num a => QOp a -> a

product :: Num a => QOp a -> a

Foldable IPName

Methods

fold :: Monoid m => IPName m -> m

foldMap :: Monoid m => (a -> m) -> IPName a -> m

foldr :: (a -> b -> b) -> b -> IPName a -> b

foldr' :: (a -> b -> b) -> b -> IPName a -> b

foldl :: (b -> a -> b) -> b -> IPName a -> b

foldl' :: (b -> a -> b) -> b -> IPName a -> b

foldr1 :: (a -> a -> a) -> IPName a -> a

foldl1 :: (a -> a -> a) -> IPName a -> a

toList :: IPName a -> [a]

null :: IPName a -> Bool

length :: IPName a -> Int

elem :: Eq a => a -> IPName a -> Bool

maximum :: Ord a => IPName a -> a

minimum :: Ord a => IPName a -> a

sum :: Num a => IPName a -> a

product :: Num a => IPName a -> a

Foldable Name

Methods

fold :: Monoid m => Name m -> m

foldMap :: Monoid m => (a -> m) -> Name a -> m

foldr :: (a -> b -> b) -> b -> Name a -> b

foldr' :: (a -> b -> b) -> b -> Name a -> b

foldl :: (b -> a -> b) -> b -> Name a -> b

foldl' :: (b -> a -> b) -> b -> Name a -> b

foldr1 :: (a -> a -> a) -> Name a -> a

foldl1 :: (a -> a -> a) -> Name a -> a

toList :: Name a -> [a]

null :: Name a -> Bool

length :: Name a -> Int

elem :: Eq a => a -> Name a -> Bool

maximum :: Ord a => Name a -> a

minimum :: Ord a => Name a -> a

sum :: Num a => Name a -> a

product :: Num a => Name a -> a

Foldable QName

Methods

fold :: Monoid m => QName m -> m

foldMap :: Monoid m => (a -> m) -> QName a -> m

foldr :: (a -> b -> b) -> b -> QName a -> b

foldr' :: (a -> b -> b) -> b -> QName a -> b

foldl :: (b -> a -> b) -> b -> QName a -> b

foldl' :: (b -> a -> b) -> b -> QName a -> b

foldr1 :: (a -> a -> a) -> QName a -> a

foldl1 :: (a -> a -> a) -> QName a -> a

toList :: QName a -> [a]

null :: QName a -> Bool

length :: QName a -> Int

elem :: Eq a => a -> QName a -> Bool

maximum :: Ord a => QName a -> a

minimum :: Ord a => QName a -> a

sum :: Num a => QName a -> a

product :: Num a => QName a -> a

Foldable SpecialCon

Methods

fold :: Monoid m => SpecialCon m -> m

foldMap :: Monoid m => (a -> m) -> SpecialCon a -> m

foldr :: (a -> b -> b) -> b -> SpecialCon a -> b

foldr' :: (a -> b -> b) -> b -> SpecialCon a -> b

foldl :: (b -> a -> b) -> b -> SpecialCon a -> b

foldl' :: (b -> a -> b) -> b -> SpecialCon a -> b

foldr1 :: (a -> a -> a) -> SpecialCon a -> a

foldl1 :: (a -> a -> a) -> SpecialCon a -> a

toList :: SpecialCon a -> [a]

null :: SpecialCon a -> Bool

length :: SpecialCon a -> Int

elem :: Eq a => a -> SpecialCon a -> Bool

maximum :: Ord a => SpecialCon a -> a

minimum :: Ord a => SpecialCon a -> a

sum :: Num a => SpecialCon a -> a

product :: Num a => SpecialCon a -> a

Foldable ModuleName

Methods

fold :: Monoid m => ModuleName m -> m

foldMap :: Monoid m => (a -> m) -> ModuleName a -> m

foldr :: (a -> b -> b) -> b -> ModuleName a -> b

foldr' :: (a -> b -> b) -> b -> ModuleName a -> b

foldl :: (b -> a -> b) -> b -> ModuleName a -> b

foldl' :: (b -> a -> b) -> b -> ModuleName a -> b

foldr1 :: (a -> a -> a) -> ModuleName a -> a

foldl1 :: (a -> a -> a) -> ModuleName a -> a

toList :: ModuleName a -> [a]

null :: ModuleName a -> Bool

length :: ModuleName a -> Int

elem :: Eq a => a -> ModuleName a -> Bool

maximum :: Ord a => ModuleName a -> a

minimum :: Ord a => ModuleName a -> a

sum :: Num a => ModuleName a -> a

product :: Num a => ModuleName a -> a

Foldable FieldDecl

Methods

fold :: Monoid m => FieldDecl m -> m

foldMap :: Monoid m => (a -> m) -> FieldDecl a -> m

foldr :: (a -> b -> b) -> b -> FieldDecl a -> b

foldr' :: (a -> b -> b) -> b -> FieldDecl a -> b

foldl :: (b -> a -> b) -> b -> FieldDecl a -> b

foldl' :: (b -> a -> b) -> b -> FieldDecl a -> b

foldr1 :: (a -> a -> a) -> FieldDecl a -> a

foldl1 :: (a -> a -> a) -> FieldDecl a -> a

toList :: FieldDecl a -> [a]

null :: FieldDecl a -> Bool

length :: FieldDecl a -> Int

elem :: Eq a => a -> FieldDecl a -> Bool

maximum :: Ord a => FieldDecl a -> a

minimum :: Ord a => FieldDecl a -> a

sum :: Num a => FieldDecl a -> a

product :: Num a => FieldDecl a -> a

Foldable HashSet

Methods

fold :: Monoid m => HashSet m -> m

foldMap :: Monoid m => (a -> m) -> HashSet a -> m

foldr :: (a -> b -> b) -> b -> HashSet a -> b

foldr' :: (a -> b -> b) -> b -> HashSet a -> b

foldl :: (b -> a -> b) -> b -> HashSet a -> b

foldl' :: (b -> a -> b) -> b -> HashSet a -> b

foldr1 :: (a -> a -> a) -> HashSet a -> a

foldl1 :: (a -> a -> a) -> HashSet a -> a

toList :: HashSet a -> [a]

null :: HashSet a -> Bool

length :: HashSet a -> Int

elem :: Eq a => a -> HashSet a -> Bool

maximum :: Ord a => HashSet a -> a

minimum :: Ord a => HashSet a -> a

sum :: Num a => HashSet a -> a

product :: Num a => HashSet a -> a

Foldable I

Methods

fold :: Monoid m => I m -> m

foldMap :: Monoid m => (a -> m) -> I a -> m

foldr :: (a -> b -> b) -> b -> I a -> b

foldr' :: (a -> b -> b) -> b -> I a -> b

foldl :: (b -> a -> b) -> b -> I a -> b

foldl' :: (b -> a -> b) -> b -> I a -> b

foldr1 :: (a -> a -> a) -> I a -> a

foldl1 :: (a -> a -> a) -> I a -> a

toList :: I a -> [a]

null :: I a -> Bool

length :: I a -> Int

elem :: Eq a => a -> I a -> Bool

maximum :: Ord a => I a -> a

minimum :: Ord a => I a -> a

sum :: Num a => I a -> a

product :: Num a => I a -> a

Foldable (Either a)

Methods

fold :: Monoid m => Either a m -> m

foldMap :: Monoid m => (a -> m) -> Either a a -> m

foldr :: (a -> b -> b) -> b -> Either a a -> b

foldr' :: (a -> b -> b) -> b -> Either a a -> b

foldl :: (b -> a -> b) -> b -> Either a a -> b

foldl' :: (b -> a -> b) -> b -> Either a a -> b

foldr1 :: (a -> a -> a) -> Either a a -> a

foldl1 :: (a -> a -> a) -> Either a a -> a

toList :: Either a a -> [a]

null :: Either a a -> Bool

length :: Either a a -> Int

elem :: Eq a => a -> Either a a -> Bool

maximum :: Ord a => Either a a -> a

minimum :: Ord a => Either a a -> a

sum :: Num a => Either a a -> a

product :: Num a => Either a a -> a

Foldable f => Foldable (Rec1 f)

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)

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)

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)

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)

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)

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 ()))

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 ((,) a)

Methods

fold :: Monoid m => (a, m) -> m

foldMap :: Monoid m => (a -> m) -> (a, a) -> m

foldr :: (a -> b -> b) -> b -> (a, a) -> b

foldr' :: (a -> b -> b) -> b -> (a, a) -> b

foldl :: (b -> a -> b) -> b -> (a, a) -> b

foldl' :: (b -> a -> b) -> b -> (a, a) -> b

foldr1 :: (a -> a -> a) -> (a, a) -> a

foldl1 :: (a -> a -> a) -> (a, a) -> a

toList :: (a, a) -> [a]

null :: (a, a) -> Bool

length :: (a, a) -> Int

elem :: Eq a => a -> (a, a) -> Bool

maximum :: Ord a => (a, a) -> a

minimum :: Ord a => (a, a) -> a

sum :: Num a => (a, a) -> a

product :: Num a => (a, a) -> a

Foldable (Array i)

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 (Arg a)

Methods

fold :: Monoid m => Arg a m -> m

foldMap :: Monoid m => (a -> m) -> Arg a a -> m

foldr :: (a -> b -> b) -> b -> Arg a a -> b

foldr' :: (a -> b -> b) -> b -> Arg a a -> b

foldl :: (b -> a -> b) -> b -> Arg a a -> b

foldl' :: (b -> a -> b) -> b -> Arg a a -> b

foldr1 :: (a -> a -> a) -> Arg a a -> a

foldl1 :: (a -> a -> a) -> Arg a a -> a

toList :: Arg a a -> [a]

null :: Arg a a -> Bool

length :: Arg a a -> Int

elem :: Eq a => a -> Arg a a -> Bool

maximum :: Ord a => Arg a a -> a

minimum :: Ord a => Arg a a -> a

sum :: Num a => Arg a a -> a

product :: Num a => Arg a a -> a

Foldable (Proxy *)

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)

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 (ListT f)

Methods

fold :: Monoid m => ListT f m -> m

foldMap :: Monoid m => (a -> m) -> ListT f a -> m

foldr :: (a -> b -> b) -> b -> ListT f a -> b

foldr' :: (a -> b -> b) -> b -> ListT f a -> b

foldl :: (b -> a -> b) -> b -> ListT f a -> b

foldl' :: (b -> a -> b) -> b -> ListT f a -> b

foldr1 :: (a -> a -> a) -> ListT f a -> a

foldl1 :: (a -> a -> a) -> ListT f a -> a

toList :: ListT f a -> [a]

null :: ListT f a -> Bool

length :: ListT f a -> Int

elem :: Eq a => a -> ListT f a -> Bool

maximum :: Ord a => ListT f a -> a

minimum :: Ord a => ListT f a -> a

sum :: Num a => ListT f a -> a

product :: Num a => ListT f a -> a

Foldable f => Foldable (MaybeT f)

Methods

fold :: Monoid m => MaybeT f m -> m

foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m

foldr :: (a -> b -> b) -> b -> MaybeT f a -> b

foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b

foldl :: (b -> a -> b) -> b -> MaybeT f a -> b

foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b

foldr1 :: (a -> a -> a) -> MaybeT f a -> a

foldl1 :: (a -> a -> a) -> MaybeT f a -> a

toList :: MaybeT f a -> [a]

null :: MaybeT f a -> Bool

length :: MaybeT f a -> Int

elem :: Eq a => a -> MaybeT f a -> Bool

maximum :: Ord a => MaybeT f a -> a

minimum :: Ord a => MaybeT f a -> a

sum :: Num a => MaybeT f a -> a

product :: Num a => MaybeT f a -> a

Foldable (HashMap k)

Methods

fold :: Monoid m => HashMap k m -> m

foldMap :: Monoid m => (a -> m) -> HashMap k a -> m

foldr :: (a -> b -> b) -> b -> HashMap k a -> b

foldr' :: (a -> b -> b) -> b -> HashMap k a -> b

foldl :: (b -> a -> b) -> b -> HashMap k a -> b

foldl' :: (b -> a -> b) -> b -> HashMap k a -> b

foldr1 :: (a -> a -> a) -> HashMap k a -> a

foldl1 :: (a -> a -> a) -> HashMap k a -> a

toList :: HashMap k a -> [a]

null :: HashMap k a -> Bool

length :: HashMap k a -> Int

elem :: Eq a => a -> HashMap k a -> Bool

maximum :: Ord a => HashMap k a -> a

minimum :: Ord a => HashMap k a -> a

sum :: Num a => HashMap k a -> a

product :: Num a => HashMap k a -> a

Foldable (K a)

Methods

fold :: Monoid m => K a m -> m

foldMap :: Monoid m => (a -> m) -> K a a -> m

foldr :: (a -> b -> b) -> b -> K a a -> b

foldr' :: (a -> b -> b) -> b -> K a a -> b

foldl :: (b -> a -> b) -> b -> K a a -> b

foldl' :: (b -> a -> b) -> b -> K a a -> b

foldr1 :: (a -> a -> a) -> K a a -> a

foldl1 :: (a -> a -> a) -> K a a -> a

toList :: K a a -> [a]

null :: K a a -> Bool

length :: K a a -> Int

elem :: Eq a => a -> K a a -> Bool

maximum :: Ord a => K a a -> a

minimum :: Ord a => K a a -> a

sum :: Num a => K a a -> a

product :: Num a => K a a -> a

Foldable (NumMap k)

Methods

fold :: Monoid m => NumMap k m -> m

foldMap :: Monoid m => (a -> m) -> NumMap k a -> m

foldr :: (a -> b -> b) -> b -> NumMap k a -> b

foldr' :: (a -> b -> b) -> b -> NumMap k a -> b

foldl :: (b -> a -> b) -> b -> NumMap k a -> b

foldl' :: (b -> a -> b) -> b -> NumMap k a -> b

foldr1 :: (a -> a -> a) -> NumMap k a -> a

foldl1 :: (a -> a -> a) -> NumMap k a -> a

toList :: NumMap k a -> [a]

null :: NumMap k a -> Bool

length :: NumMap k a -> Int

elem :: Eq a => a -> NumMap k a -> Bool

maximum :: Ord a => NumMap k a -> a

minimum :: Ord a => NumMap k a -> a

sum :: Num a => NumMap k a -> a

product :: Num a => NumMap k a -> a

Foldable (K1 i c)

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)

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)

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)

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 (Const * m)

Methods

fold :: Monoid m => Const * m m -> m

foldMap :: Monoid m => (a -> m) -> Const * m a -> m

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 f => Foldable (ErrorT e f)

Methods

fold :: Monoid m => ErrorT e f m -> m

foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m

foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldr1 :: (a -> a -> a) -> ErrorT e f a -> a

foldl1 :: (a -> a -> a) -> ErrorT e f a -> a

toList :: ErrorT e f a -> [a]

null :: ErrorT e f a -> Bool

length :: ErrorT e f a -> Int

elem :: Eq a => a -> ErrorT e f a -> Bool

maximum :: Ord a => ErrorT e f a -> a

minimum :: Ord a => ErrorT e f a -> a

sum :: Num a => ErrorT e f a -> a

product :: Num a => ErrorT e f a -> a

Foldable f => Foldable (ExceptT e f)

Methods

fold :: Monoid m => ExceptT e f m -> m

foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m

foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b

foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b

foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b

foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b

foldr1 :: (a -> a -> a) -> ExceptT e f a -> a

foldl1 :: (a -> a -> a) -> ExceptT e f a -> a

toList :: ExceptT e f a -> [a]

null :: ExceptT e f a -> Bool

length :: ExceptT e f a -> Int

elem :: Eq a => a -> ExceptT e f a -> Bool

maximum :: Ord a => ExceptT e f a -> a

minimum :: Ord a => ExceptT e f a -> a

sum :: Num a => ExceptT e f a -> a

product :: Num a => ExceptT e f a -> a

Foldable f => Foldable (WriterT w f)

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 f => Foldable (WriterT w f)

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 f => Foldable (IdentityT * f)

Methods

fold :: Monoid m => IdentityT * f m -> m

foldMap :: Monoid m => (a -> m) -> IdentityT * f a -> m

foldr :: (a -> b -> b) -> b -> IdentityT * f a -> b

foldr' :: (a -> b -> b) -> b -> IdentityT * f a -> b

foldl :: (b -> a -> b) -> b -> IdentityT * f a -> b

foldl' :: (b -> a -> b) -> b -> IdentityT * f a -> b

foldr1 :: (a -> a -> a) -> IdentityT * f a -> a

foldl1 :: (a -> a -> a) -> IdentityT * f a -> a

toList :: IdentityT * f a -> [a]

null :: IdentityT * f a -> Bool

length :: IdentityT * f a -> Int

elem :: Eq a => a -> IdentityT * f a -> Bool

maximum :: Ord a => IdentityT * f a -> a

minimum :: Ord a => IdentityT * f a -> a

sum :: Num a => IdentityT * f a -> a

product :: Num a => IdentityT * f a -> a

Foldable f => Foldable (Cxt h f)

Methods

fold :: Monoid m => Cxt h f m -> m

foldMap :: Monoid m => (a -> m) -> Cxt h f a -> m

foldr :: (a -> b -> b) -> b -> Cxt h f a -> b

foldr' :: (a -> b -> b) -> b -> Cxt h f a -> b

foldl :: (b -> a -> b) -> b -> Cxt h f a -> b

foldl' :: (b -> a -> b) -> b -> Cxt h f a -> b

foldr1 :: (a -> a -> a) -> Cxt h f a -> a

foldl1 :: (a -> a -> a) -> Cxt h f a -> a

toList :: Cxt h f a -> [a]

null :: Cxt h f a -> Bool

length :: Cxt h f a -> Int

elem :: Eq a => a -> Cxt h f a -> Bool

maximum :: Ord a => Cxt h f a -> a

minimum :: Ord a => Cxt h f a -> a

sum :: Num a => Cxt h f a -> a

product :: Num a => Cxt h f a -> a

Foldable f => Foldable (M1 i c f)

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 (Sum * f g)

Methods

fold :: Monoid m => Sum * f g m -> m

foldMap :: Monoid m => (a -> m) -> Sum * f g a -> m

foldr :: (a -> b -> b) -> b -> Sum * f g a -> b

foldr' :: (a -> b -> b) -> b -> Sum * f g a -> b

foldl :: (b -> a -> b) -> b -> Sum * f g a -> b

foldl' :: (b -> a -> b) -> b -> Sum * f g a -> b

foldr1 :: (a -> a -> a) -> Sum * f g a -> a

foldl1 :: (a -> a -> a) -> Sum * f g a -> a

toList :: Sum * f g a -> [a]

null :: Sum * f g a -> Bool

length :: Sum * f g a -> Int

elem :: Eq a => a -> Sum * f g a -> Bool

maximum :: Ord a => Sum * f g a -> a

minimum :: Ord a => Sum * f g a -> a

sum :: Num a => Sum * f g a -> a

product :: Num a => Sum * f g a -> a

(Foldable f, Foldable g) => Foldable (Product * f g)

Methods

fold :: Monoid m => Product * f g m -> m

foldMap :: Monoid m => (a -> m) -> Product * f g a -> m

foldr :: (a -> b -> b) -> b -> Product * f g a -> b

foldr' :: (a -> b -> b) -> b -> Product * f g a -> b

foldl :: (b -> a -> b) -> b -> Product * f g a -> b

foldl' :: (b -> a -> b) -> b -> Product * f g a -> b

foldr1 :: (a -> a -> a) -> Product * f g a -> a

foldl1 :: (a -> a -> a) -> Product * f g a -> a

toList :: Product * f g a -> [a]

null :: Product * f g a -> Bool

length :: Product * f g a -> Int

elem :: Eq a => a -> Product * f g a -> Bool

maximum :: Ord a => Product * f g a -> a

minimum :: Ord a => Product * f g a -> a

sum :: Num a => Product * f g a -> a

product :: Num a => Product * f g a -> a

Foldable f => Foldable ((:&:) * f a)

Methods

fold :: Monoid m => (* :&: f) a m -> m

foldMap :: Monoid m => (a -> m) -> (* :&: f) a a -> m

foldr :: (a -> b -> b) -> b -> (* :&: f) a a -> b

foldr' :: (a -> b -> b) -> b -> (* :&: f) a a -> b

foldl :: (b -> a -> b) -> b -> (* :&: f) a a -> b

foldl' :: (b -> a -> b) -> b -> (* :&: f) a a -> b

foldr1 :: (a -> a -> a) -> (* :&: f) a a -> a

foldl1 :: (a -> a -> a) -> (* :&: f) a a -> a

toList :: (* :&: f) a a -> [a]

null :: (* :&: f) a a -> Bool

length :: (* :&: f) a a -> Int

elem :: Eq a => a -> (* :&: f) a a -> Bool

maximum :: Ord a => (* :&: f) a a -> a

minimum :: Ord a => (* :&: f) a a -> a

sum :: Num a => (* :&: f) a a -> a

product :: Num a => (* :&: f) a a -> a

(Foldable f, Foldable g) => Foldable ((:*:) * f g)

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)

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)

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

makeFoldable :: Name -> Q [Dec]

Derive an instance of Foldable for a type constructor of any first-order kind taking at least one argument.

Traversable

class (Functor t, Foldable t) => Traversable t

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

naturality

t . traverse f = traverse (t . f) for every applicative transformation t

identity

traverse Identity = Identity

composition

traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality

t . sequenceA = sequenceA . fmap t for every applicative transformation t

identity

sequenceA . fmap Identity = Identity

composition

sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

• t (pure x) = pure x

• t (x <*> y) = t x <*> t y

and the identity functor Identity and composition of functors Compose are defined as

  newtype Identity a = Identity a

  instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

  instance Applicative Identity where
    pure x = Identity x
    Identity f <*> Identity x = Identity (f x)

  newtype Compose f g a = Compose (f (g a))

  instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
    pure x = Compose (pure (pure x))
    Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(The naturality law is implied by parametricity.)

Instances are similar to Functor, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

• In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor (fmapDefault).
• In the Foldable instance, foldMap should be equivalent to traversal with a constant applicative functor (foldMapDefault).

Minimal complete definition

traverse | sequenceA

Instances

Traversable []

Methods

traverse :: Applicative f => (a -> f b) -> [a] -> f [b]

sequenceA :: Applicative f => [f a] -> f [a]

mapM :: Monad m => (a -> m b) -> [a] -> m [b]

sequence :: Monad m => [m a] -> m [a]

Traversable Maybe

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b)

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a)

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)

sequence :: Monad m => Maybe (m a) -> m (Maybe a)

Traversable V1

Methods

traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b)

sequenceA :: Applicative f => V1 (f a) -> f (V1 a)

mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b)

sequence :: Monad m => V1 (m a) -> m (V1 a)

Traversable U1

Methods

traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b)

sequenceA :: Applicative f => U1 (f a) -> f (U1 a)

mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b)

sequence :: Monad m => U1 (m a) -> m (U1 a)

Traversable Par1

Methods

traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b)

sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a)

mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b)

sequence :: Monad m => Par1 (m a) -> m (Par1 a)

Traversable Identity

Methods

traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b)

sequenceA :: Applicative f => Identity (f a) -> f (Identity a)

mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b)

sequence :: Monad m => Identity (m a) -> m (Identity a)

Traversable Min

Methods

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

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

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

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

Traversable Max

Methods

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

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

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

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

Traversable First

Methods

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

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

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

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

Traversable Last

Methods

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

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

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

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

Traversable Option

Methods

traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b)

sequenceA :: Applicative f => Option (f a) -> f (Option a)

mapM :: Monad m => (a -> m b) -> Option a -> m (Option b)

sequence :: Monad m => Option (m a) -> m (Option a)

Traversable NonEmpty

Methods

traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b)

sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a)

mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b)

sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a)

Traversable Complex

Methods

traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b)

sequenceA :: Applicative f => Complex (f a) -> f (Complex a)

mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b)

sequence :: Monad m => Complex (m a) -> m (Complex a)

Traversable ZipList

Methods

traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b)

sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a)

mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b)

sequence :: Monad m => ZipList (m a) -> m (ZipList a)

Traversable Dual

Methods

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

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

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

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

Traversable Sum

Methods

traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b)

sequenceA :: Applicative f => Sum (f a) -> f (Sum a)

mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b)

sequence :: Monad m => Sum (m a) -> m (Sum a)

Traversable Product

Methods

traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b)

sequenceA :: Applicative f => Product (f a) -> f (Product a)

mapM :: Monad m => (a -> m b) -> Product a -> m (Product b)

sequence :: Monad m => Product (m a) -> m (Product a)

Traversable First

Methods

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

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

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

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

Traversable Last

Methods

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

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

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

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

Traversable Digit

Methods

traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b)

sequenceA :: Applicative f => Digit (f a) -> f (Digit a)

mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b)

sequence :: Monad m => Digit (m a) -> m (Digit a)

Traversable Node

Methods

traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b)

sequenceA :: Applicative f => Node (f a) -> f (Node a)

mapM :: Monad m => (a -> m b) -> Node a -> m (Node b)

sequence :: Monad m => Node (m a) -> m (Node a)

Traversable Elem

Methods

traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b)

sequenceA :: Applicative f => Elem (f a) -> f (Elem a)

mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b)

sequence :: Monad m => Elem (m a) -> m (Elem a)

Traversable FingerTree

Methods

traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b)

sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a)

mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b)

sequence :: Monad m => FingerTree (m a) -> m (FingerTree a)

Traversable IntMap

Methods

traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b)

sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a)

mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b)

sequence :: Monad m => IntMap (m a) -> m (IntMap a)

Traversable Tree

Methods

traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b)

sequenceA :: Applicative f => Tree (f a) -> f (Tree a)

mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b)

sequence :: Monad m => Tree (m a) -> m (Tree a)

Traversable Seq

Methods

traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b)

sequenceA :: Applicative f => Seq (f a) -> f (Seq a)

mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b)

sequence :: Monad m => Seq (m a) -> m (Seq a)

Traversable ViewL

Methods

traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b)

sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a)

mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b)

sequence :: Monad m => ViewL (m a) -> m (ViewL a)

Traversable ViewR

Methods

traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b)

sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a)

mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b)

sequence :: Monad m => ViewR (m a) -> m (ViewR a)

Traversable Alt

Methods

traverse :: Applicative f => (a -> f b) -> Alt a -> f (Alt b)

sequenceA :: Applicative f => Alt (f a) -> f (Alt a)

mapM :: Monad m => (a -> m b) -> Alt a -> m (Alt b)

sequence :: Monad m => Alt (m a) -> m (Alt a)

Traversable FieldUpdate

Methods

traverse :: Applicative f => (a -> f b) -> FieldUpdate a -> f (FieldUpdate b)

sequenceA :: Applicative f => FieldUpdate (f a) -> f (FieldUpdate a)

mapM :: Monad m => (a -> m b) -> FieldUpdate a -> m (FieldUpdate b)

sequence :: Monad m => FieldUpdate (m a) -> m (FieldUpdate a)

Traversable QualStmt

Methods

traverse :: Applicative f => (a -> f b) -> QualStmt a -> f (QualStmt b)

sequenceA :: Applicative f => QualStmt (f a) -> f (QualStmt a)

mapM :: Monad m => (a -> m b) -> QualStmt a -> m (QualStmt b)

sequence :: Monad m => QualStmt (m a) -> m (QualStmt a)

Traversable Stmt

Methods

traverse :: Applicative f => (a -> f b) -> Stmt a -> f (Stmt b)

sequenceA :: Applicative f => Stmt (f a) -> f (Stmt a)

mapM :: Monad m => (a -> m b) -> Stmt a -> m (Stmt b)

sequence :: Monad m => Stmt (m a) -> m (Stmt a)

Traversable PatField

Methods

traverse :: Applicative f => (a -> f b) -> PatField a -> f (PatField b)

sequenceA :: Applicative f => PatField (f a) -> f (PatField a)

mapM :: Monad m => (a -> m b) -> PatField a -> m (PatField b)

sequence :: Monad m => PatField (m a) -> m (PatField a)

Traversable RPat

Methods

traverse :: Applicative f => (a -> f b) -> RPat a -> f (RPat b)

sequenceA :: Applicative f => RPat (f a) -> f (RPat a)

mapM :: Monad m => (a -> m b) -> RPat a -> m (RPat b)

sequence :: Monad m => RPat (m a) -> m (RPat a)

Traversable RPatOp

Methods

traverse :: Applicative f => (a -> f b) -> RPatOp a -> f (RPatOp b)

sequenceA :: Applicative f => RPatOp (f a) -> f (RPatOp a)

mapM :: Monad m => (a -> m b) -> RPatOp a -> m (RPatOp b)

sequence :: Monad m => RPatOp (m a) -> m (RPatOp a)

Traversable PXAttr

Methods

traverse :: Applicative f => (a -> f b) -> PXAttr a -> f (PXAttr b)

sequenceA :: Applicative f => PXAttr (f a) -> f (PXAttr a)

mapM :: Monad m => (a -> m b) -> PXAttr a -> m (PXAttr b)

sequence :: Monad m => PXAttr (m a) -> m (PXAttr a)

Traversable Pat

Methods

traverse :: Applicative f => (a -> f b) -> Pat a -> f (Pat b)

sequenceA :: Applicative f => Pat (f a) -> f (Pat a)

mapM :: Monad m => (a -> m b) -> Pat a -> m (Pat b)

sequence :: Monad m => Pat (m a) -> m (Pat a)

Traversable WarningText

Methods

traverse :: Applicative f => (a -> f b) -> WarningText a -> f (WarningText b)

sequenceA :: Applicative f => WarningText (f a) -> f (WarningText a)

mapM :: Monad m => (a -> m b) -> WarningText a -> m (WarningText b)

sequence :: Monad m => WarningText (m a) -> m (WarningText a)

Traversable RuleVar

Methods

traverse :: Applicative f => (a -> f b) -> RuleVar a -> f (RuleVar b)

sequenceA :: Applicative f => RuleVar (f a) -> f (RuleVar a)

mapM :: Monad m => (a -> m b) -> RuleVar a -> m (RuleVar b)

sequence :: Monad m => RuleVar (m a) -> m (RuleVar a)

Traversable Rule

Methods

traverse :: Applicative f => (a -> f b) -> Rule a -> f (Rule b)

sequenceA :: Applicative f => Rule (f a) -> f (Rule a)

mapM :: Monad m => (a -> m b) -> Rule a -> m (Rule b)

sequence :: Monad m => Rule (m a) -> m (Rule a)

Traversable Activation

Methods

traverse :: Applicative f => (a -> f b) -> Activation a -> f (Activation b)

sequenceA :: Applicative f => Activation (f a) -> f (Activation a)

mapM :: Monad m => (a -> m b) -> Activation a -> m (Activation b)

sequence :: Monad m => Activation (m a) -> m (Activation a)

Traversable Overlap

Methods

traverse :: Applicative f => (a -> f b) -> Overlap a -> f (Overlap b)

sequenceA :: Applicative f => Overlap (f a) -> f (Overlap a)

mapM :: Monad m => (a -> m b) -> Overlap a -> m (Overlap b)

sequence :: Monad m => Overlap (m a) -> m (Overlap a)

Traversable ModulePragma

Methods

traverse :: Applicative f => (a -> f b) -> ModulePragma a -> f (ModulePragma b)

sequenceA :: Applicative f => ModulePragma (f a) -> f (ModulePragma a)

mapM :: Monad m => (a -> m b) -> ModulePragma a -> m (ModulePragma b)

sequence :: Monad m => ModulePragma (m a) -> m (ModulePragma a)

Traversable CallConv

Methods

traverse :: Applicative f => (a -> f b) -> CallConv a -> f (CallConv b)

sequenceA :: Applicative f => CallConv (f a) -> f (CallConv a)

mapM :: Monad m => (a -> m b) -> CallConv a -> m (CallConv b)

sequence :: Monad m => CallConv (m a) -> m (CallConv a)

Traversable Safety

Methods

traverse :: Applicative f => (a -> f b) -> Safety a -> f (Safety b)

sequenceA :: Applicative f => Safety (f a) -> f (Safety a)

mapM :: Monad m => (a -> m b) -> Safety a -> m (Safety b)

sequence :: Monad m => Safety (m a) -> m (Safety a)

Traversable Splice

Methods

traverse :: Applicative f => (a -> f b) -> Splice a -> f (Splice b)

sequenceA :: Applicative f => Splice (f a) -> f (Splice a)

mapM :: Monad m => (a -> m b) -> Splice a -> m (Splice b)

sequence :: Monad m => Splice (m a) -> m (Splice a)

Traversable Bracket

Methods

traverse :: Applicative f => (a -> f b) -> Bracket a -> f (Bracket b)

sequenceA :: Applicative f => Bracket (f a) -> f (Bracket a)

mapM :: Monad m => (a -> m b) -> Bracket a -> m (Bracket b)

sequence :: Monad m => Bracket (m a) -> m (Bracket a)

Traversable XAttr

Methods

traverse :: Applicative f => (a -> f b) -> XAttr a -> f (XAttr b)

sequenceA :: Applicative f => XAttr (f a) -> f (XAttr a)

mapM :: Monad m => (a -> m b) -> XAttr a -> m (XAttr b)

sequence :: Monad m => XAttr (m a) -> m (XAttr a)

Traversable XName

Methods

traverse :: Applicative f => (a -> f b) -> XName a -> f (XName b)

sequenceA :: Applicative f => XName (f a) -> f (XName a)

mapM :: Monad m => (a -> m b) -> XName a -> m (XName b)

sequence :: Monad m => XName (m a) -> m (XName a)

Traversable Exp

Methods

traverse :: Applicative f => (a -> f b) -> Exp a -> f (Exp b)

sequenceA :: Applicative f => Exp (f a) -> f (Exp a)

mapM :: Monad m => (a -> m b) -> Exp a -> m (Exp b)

sequence :: Monad m => Exp (m a) -> m (Exp a)

Traversable Sign

Methods

traverse :: Applicative f => (a -> f b) -> Sign a -> f (Sign b)

sequenceA :: Applicative f => Sign (f a) -> f (Sign a)

mapM :: Monad m => (a -> m b) -> Sign a -> m (Sign b)

sequence :: Monad m => Sign (m a) -> m (Sign a)

Traversable Literal

Methods

traverse :: Applicative f => (a -> f b) -> Literal a -> f (Literal b)

sequenceA :: Applicative f => Literal (f a) -> f (Literal a)

mapM :: Monad m => (a -> m b) -> Literal a -> m (Literal b)

sequence :: Monad m => Literal (m a) -> m (Literal a)

Traversable Asst

Methods

traverse :: Applicative f => (a -> f b) -> Asst a -> f (Asst b)

sequenceA :: Applicative f => Asst (f a) -> f (Asst a)

mapM :: Monad m => (a -> m b) -> Asst a -> m (Asst b)

sequence :: Monad m => Asst (m a) -> m (Asst a)

Traversable Context

Methods

traverse :: Applicative f => (a -> f b) -> Context a -> f (Context b)

sequenceA :: Applicative f => Context (f a) -> f (Context a)

mapM :: Monad m => (a -> m b) -> Context a -> m (Context b)

sequence :: Monad m => Context (m a) -> m (Context a)

Traversable FunDep

Methods

traverse :: Applicative f => (a -> f b) -> FunDep a -> f (FunDep b)

sequenceA :: Applicative f => FunDep (f a) -> f (FunDep a)

mapM :: Monad m => (a -> m b) -> FunDep a -> m (FunDep b)

sequence :: Monad m => FunDep (m a) -> m (FunDep a)

Traversable Kind

Methods

traverse :: Applicative f => (a -> f b) -> Kind a -> f (Kind b)

sequenceA :: Applicative f => Kind (f a) -> f (Kind a)

mapM :: Monad m => (a -> m b) -> Kind a -> m (Kind b)

sequence :: Monad m => Kind (m a) -> m (Kind a)

Traversable TyVarBind

Methods

traverse :: Applicative f => (a -> f b) -> TyVarBind a -> f (TyVarBind b)

sequenceA :: Applicative f => TyVarBind (f a) -> f (TyVarBind a)

mapM :: Monad m => (a -> m b) -> TyVarBind a -> m (TyVarBind b)

sequence :: Monad m => TyVarBind (m a) -> m (TyVarBind a)

Traversable Promoted

Methods

traverse :: Applicative f => (a -> f b) -> Promoted a -> f (Promoted b)

sequenceA :: Applicative f => Promoted (f a) -> f (Promoted a)

mapM :: Monad m => (a -> m b) -> Promoted a -> m (Promoted b)

sequence :: Monad m => Promoted (m a) -> m (Promoted a)

Traversable Type

Methods

traverse :: Applicative f => (a -> f b) -> Type a -> f (Type b)

sequenceA :: Applicative f => Type (f a) -> f (Type a)

mapM :: Monad m => (a -> m b) -> Type a -> m (Type b)

sequence :: Monad m => Type (m a) -> m (Type a)

Traversable GuardedRhs

Methods

traverse :: Applicative f => (a -> f b) -> GuardedRhs a -> f (GuardedRhs b)

sequenceA :: Applicative f => GuardedRhs (f a) -> f (GuardedRhs a)

mapM :: Monad m => (a -> m b) -> GuardedRhs a -> m (GuardedRhs b)

sequence :: Monad m => GuardedRhs (m a) -> m (GuardedRhs a)

Traversable Rhs

Methods

traverse :: Applicative f => (a -> f b) -> Rhs a -> f (Rhs b)

sequenceA :: Applicative f => Rhs (f a) -> f (Rhs a)

mapM :: Monad m => (a -> m b) -> Rhs a -> m (Rhs b)

sequence :: Monad m => Rhs (m a) -> m (Rhs a)

Traversable Unpackedness

Methods

traverse :: Applicative f => (a -> f b) -> Unpackedness a -> f (Unpackedness b)

sequenceA :: Applicative f => Unpackedness (f a) -> f (Unpackedness a)

mapM :: Monad m => (a -> m b) -> Unpackedness a -> m (Unpackedness b)

sequence :: Monad m => Unpackedness (m a) -> m (Unpackedness a)

Traversable BangType

Methods

traverse :: Applicative f => (a -> f b) -> BangType a -> f (BangType b)

sequenceA :: Applicative f => BangType (f a) -> f (BangType a)

mapM :: Monad m => (a -> m b) -> BangType a -> m (BangType b)

sequence :: Monad m => BangType (m a) -> m (BangType a)

Traversable InstDecl

Methods

traverse :: Applicative f => (a -> f b) -> InstDecl a -> f (InstDecl b)

sequenceA :: Applicative f => InstDecl (f a) -> f (InstDecl a)

mapM :: Monad m => (a -> m b) -> InstDecl a -> m (InstDecl b)

sequence :: Monad m => InstDecl (m a) -> m (InstDecl a)

Traversable ClassDecl

Methods

traverse :: Applicative f => (a -> f b) -> ClassDecl a -> f (ClassDecl b)

sequenceA :: Applicative f => ClassDecl (f a) -> f (ClassDecl a)

mapM :: Monad m => (a -> m b) -> ClassDecl a -> m (ClassDecl b)

sequence :: Monad m => ClassDecl (m a) -> m (ClassDecl a)

Traversable GadtDecl

Methods

traverse :: Applicative f => (a -> f b) -> GadtDecl a -> f (GadtDecl b)

sequenceA :: Applicative f => GadtDecl (f a) -> f (GadtDecl a)

mapM :: Monad m => (a -> m b) -> GadtDecl a -> m (GadtDecl b)

sequence :: Monad m => GadtDecl (m a) -> m (GadtDecl a)

Traversable ConDecl

Methods

traverse :: Applicative f => (a -> f b) -> ConDecl a -> f (ConDecl b)

sequenceA :: Applicative f => ConDecl (f a) -> f (ConDecl a)

mapM :: Monad m => (a -> m b) -> ConDecl a -> m (ConDecl b)

sequence :: Monad m => ConDecl (m a) -> m (ConDecl a)

Traversable QualConDecl

Methods

traverse :: Applicative f => (a -> f b) -> QualConDecl a -> f (QualConDecl b)

sequenceA :: Applicative f => QualConDecl (f a) -> f (QualConDecl a)

mapM :: Monad m => (a -> m b) -> QualConDecl a -> m (QualConDecl b)

sequence :: Monad m => QualConDecl (m a) -> m (QualConDecl a)

Traversable Match

Methods

traverse :: Applicative f => (a -> f b) -> Match a -> f (Match b)

sequenceA :: Applicative f => Match (f a) -> f (Match a)

mapM :: Monad m => (a -> m b) -> Match a -> m (Match b)

sequence :: Monad m => Match (m a) -> m (Match a)

Traversable IPBind

Methods

traverse :: Applicative f => (a -> f b) -> IPBind a -> f (IPBind b)

sequenceA :: Applicative f => IPBind (f a) -> f (IPBind a)

mapM :: Monad m => (a -> m b) -> IPBind a -> m (IPBind b)

sequence :: Monad m => IPBind (m a) -> m (IPBind a)

Traversable Binds

Methods

traverse :: Applicative f => (a -> f b) -> Binds a -> f (Binds b)

sequenceA :: Applicative f => Binds (f a) -> f (Binds a)

mapM :: Monad m => (a -> m b) -> Binds a -> m (Binds b)

sequence :: Monad m => Binds (m a) -> m (Binds a)

Traversable Deriving

Methods

traverse :: Applicative f => (a -> f b) -> Deriving a -> f (Deriving b)

sequenceA :: Applicative f => Deriving (f a) -> f (Deriving a)

mapM :: Monad m => (a -> m b) -> Deriving a -> m (Deriving b)

sequence :: Monad m => Deriving (m a) -> m (Deriving a)

Traversable InstHead

Methods

traverse :: Applicative f => (a -> f b) -> InstHead a -> f (InstHead b)

sequenceA :: Applicative f => InstHead (f a) -> f (InstHead a)

mapM :: Monad m => (a -> m b) -> InstHead a -> m (InstHead b)

sequence :: Monad m => InstHead (m a) -> m (InstHead a)

Traversable InstRule

Methods

traverse :: Applicative f => (a -> f b) -> InstRule a -> f (InstRule b)

sequenceA :: Applicative f => InstRule (f a) -> f (InstRule a)

mapM :: Monad m => (a -> m b) -> InstRule a -> m (InstRule b)

sequence :: Monad m => InstRule (m a) -> m (InstRule a)

Traversable DeclHead

Methods

traverse :: Applicative f => (a -> f b) -> DeclHead a -> f (DeclHead b)

sequenceA :: Applicative f => DeclHead (f a) -> f (DeclHead a)

mapM :: Monad m => (a -> m b) -> DeclHead a -> m (DeclHead b)

sequence :: Monad m => DeclHead (m a) -> m (DeclHead a)

Traversable ResultSig

Methods

traverse :: Applicative f => (a -> f b) -> ResultSig a -> f (ResultSig b)

sequenceA :: Applicative f => ResultSig (f a) -> f (ResultSig a)

mapM :: Monad m => (a -> m b) -> ResultSig a -> m (ResultSig b)

sequence :: Monad m => ResultSig (m a) -> m (ResultSig a)

Traversable InjectivityInfo

Methods

traverse :: Applicative f => (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b)

sequenceA :: Applicative f => InjectivityInfo (f a) -> f (InjectivityInfo a)

mapM :: Monad m => (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b)

sequence :: Monad m => InjectivityInfo (m a) -> m (InjectivityInfo a)

Traversable DataOrNew

Methods

traverse :: Applicative f => (a -> f b) -> DataOrNew a -> f (DataOrNew b)

sequenceA :: Applicative f => DataOrNew (f a) -> f (DataOrNew a)

mapM :: Monad m => (a -> m b) -> DataOrNew a -> m (DataOrNew b)

sequence :: Monad m => DataOrNew (m a) -> m (DataOrNew a)

Traversable Role

Methods

traverse :: Applicative f => (a -> f b) -> Role a -> f (Role b)

sequenceA :: Applicative f => Role (f a) -> f (Role a)

mapM :: Monad m => (a -> m b) -> Role a -> m (Role b)

sequence :: Monad m => Role (m a) -> m (Role a)

Traversable BooleanFormula

Methods

traverse :: Applicative f => (a -> f b) -> BooleanFormula a -> f (BooleanFormula b)

sequenceA :: Applicative f => BooleanFormula (f a) -> f (BooleanFormula a)

mapM :: Monad m => (a -> m b) -> BooleanFormula a -> m (BooleanFormula b)

sequence :: Monad m => BooleanFormula (m a) -> m (BooleanFormula a)

Traversable Annotation

Methods

traverse :: Applicative f => (a -> f b) -> Annotation a -> f (Annotation b)

sequenceA :: Applicative f => Annotation (f a) -> f (Annotation a)

mapM :: Monad m => (a -> m b) -> Annotation a -> m (Annotation b)

sequence :: Monad m => Annotation (m a) -> m (Annotation a)

Traversable TypeEqn

Methods

traverse :: Applicative f => (a -> f b) -> TypeEqn a -> f (TypeEqn b)

sequenceA :: Applicative f => TypeEqn (f a) -> f (TypeEqn a)

mapM :: Monad m => (a -> m b) -> TypeEqn a -> m (TypeEqn b)

sequence :: Monad m => TypeEqn (m a) -> m (TypeEqn a)

Traversable PatternSynDirection

Methods

traverse :: Applicative f => (a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b)

sequenceA :: Applicative f => PatternSynDirection (f a) -> f (PatternSynDirection a)

mapM :: Monad m => (a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b)

sequence :: Monad m => PatternSynDirection (m a) -> m (PatternSynDirection a)

Traversable Decl

Methods

traverse :: Applicative f => (a -> f b) -> Decl a -> f (Decl b)

sequenceA :: Applicative f => Decl (f a) -> f (Decl a)

mapM :: Monad m => (a -> m b) -> Decl a -> m (Decl b)

sequence :: Monad m => Decl (m a) -> m (Decl a)

Traversable Assoc

Methods

traverse :: Applicative f => (a -> f b) -> Assoc a -> f (Assoc b)

sequenceA :: Applicative f => Assoc (f a) -> f (Assoc a)

mapM :: Monad m => (a -> m b) -> Assoc a -> m (Assoc b)

sequence :: Monad m => Assoc (m a) -> m (Assoc a)

Traversable ImportSpec

Methods

traverse :: Applicative f => (a -> f b) -> ImportSpec a -> f (ImportSpec b)

sequenceA :: Applicative f => ImportSpec (f a) -> f (ImportSpec a)

mapM :: Monad m => (a -> m b) -> ImportSpec a -> m (ImportSpec b)

sequence :: Monad m => ImportSpec (m a) -> m (ImportSpec a)

Traversable ImportSpecList

Methods

traverse :: Applicative f => (a -> f b) -> ImportSpecList a -> f (ImportSpecList b)

sequenceA :: Applicative f => ImportSpecList (f a) -> f (ImportSpecList a)

mapM :: Monad m => (a -> m b) -> ImportSpecList a -> m (ImportSpecList b)

sequence :: Monad m => ImportSpecList (m a) -> m (ImportSpecList a)

Traversable ImportDecl

Methods

traverse :: Applicative f => (a -> f b) -> ImportDecl a -> f (ImportDecl b)

sequenceA :: Applicative f => ImportDecl (f a) -> f (ImportDecl a)

mapM :: Monad m => (a -> m b) -> ImportDecl a -> m (ImportDecl b)

sequence :: Monad m => ImportDecl (m a) -> m (ImportDecl a)

Traversable Namespace

Methods

traverse :: Applicative f => (a -> f b) -> Namespace a -> f (Namespace b)

sequenceA :: Applicative f => Namespace (f a) -> f (Namespace a)

mapM :: Monad m => (a -> m b) -> Namespace a -> m (Namespace b)

sequence :: Monad m => Namespace (m a) -> m (Namespace a)

Traversable EWildcard

Methods

traverse :: Applicative f => (a -> f b) -> EWildcard a -> f (EWildcard b)

sequenceA :: Applicative f => EWildcard (f a) -> f (EWildcard a)

mapM :: Monad m => (a -> m b) -> EWildcard a -> m (EWildcard b)

sequence :: Monad m => EWildcard (m a) -> m (EWildcard a)

Traversable ExportSpec

Methods

traverse :: Applicative f => (a -> f b) -> ExportSpec a -> f (ExportSpec b)

sequenceA :: Applicative f => ExportSpec (f a) -> f (ExportSpec a)

mapM :: Monad m => (a -> m b) -> ExportSpec a -> m (ExportSpec b)

sequence :: Monad m => ExportSpec (m a) -> m (ExportSpec a)

Traversable ExportSpecList

Methods

traverse :: Applicative f => (a -> f b) -> ExportSpecList a -> f (ExportSpecList b)

sequenceA :: Applicative f => ExportSpecList (f a) -> f (ExportSpecList a)

mapM :: Monad m => (a -> m b) -> ExportSpecList a -> m (ExportSpecList b)

sequence :: Monad m => ExportSpecList (m a) -> m (ExportSpecList a)

Traversable ModuleHead

Methods

traverse :: Applicative f => (a -> f b) -> ModuleHead a -> f (ModuleHead b)

sequenceA :: Applicative f => ModuleHead (f a) -> f (ModuleHead a)

mapM :: Monad m => (a -> m b) -> ModuleHead a -> m (ModuleHead b)

sequence :: Monad m => ModuleHead (m a) -> m (ModuleHead a)

Traversable Module

Methods

traverse :: Applicative f => (a -> f b) -> Module a -> f (Module b)

sequenceA :: Applicative f => Module (f a) -> f (Module a)

mapM :: Monad m => (a -> m b) -> Module a -> m (Module b)

sequence :: Monad m => Module (m a) -> m (Module a)

Traversable CName

Methods

traverse :: Applicative f => (a -> f b) -> CName a -> f (CName b)

sequenceA :: Applicative f => CName (f a) -> f (CName a)

mapM :: Monad m => (a -> m b) -> CName a -> m (CName b)

sequence :: Monad m => CName (m a) -> m (CName a)

Traversable Op

Methods

traverse :: Applicative f => (a -> f b) -> Op a -> f (Op b)

sequenceA :: Applicative f => Op (f a) -> f (Op a)

mapM :: Monad m => (a -> m b) -> Op a -> m (Op b)

sequence :: Monad m => Op (m a) -> m (Op a)

Traversable QOp

Methods

traverse :: Applicative f => (a -> f b) -> QOp a -> f (QOp b)

sequenceA :: Applicative f => QOp (f a) -> f (QOp a)

mapM :: Monad m => (a -> m b) -> QOp a -> m (QOp b)

sequence :: Monad m => QOp (m a) -> m (QOp a)

Traversable IPName

Methods

traverse :: Applicative f => (a -> f b) -> IPName a -> f (IPName b)

sequenceA :: Applicative f => IPName (f a) -> f (IPName a)

mapM :: Monad m => (a -> m b) -> IPName a -> m (IPName b)

sequence :: Monad m => IPName (m a) -> m (IPName a)

Traversable Name

Methods

traverse :: Applicative f => (a -> f b) -> Name a -> f (Name b)

sequenceA :: Applicative f => Name (f a) -> f (Name a)

mapM :: Monad m => (a -> m b) -> Name a -> m (Name b)

sequence :: Monad m => Name (m a) -> m (Name a)

Traversable QName

Methods

traverse :: Applicative f => (a -> f b) -> QName a -> f (QName b)

sequenceA :: Applicative f => QName (f a) -> f (QName a)

mapM :: Monad m => (a -> m b) -> QName a -> m (QName b)

sequence :: Monad m => QName (m a) -> m (QName a)

Traversable SpecialCon

Methods

traverse :: Applicative f => (a -> f b) -> SpecialCon a -> f (SpecialCon b)

sequenceA :: Applicative f => SpecialCon (f a) -> f (SpecialCon a)

mapM :: Monad m => (a -> m b) -> SpecialCon a -> m (SpecialCon b)

sequence :: Monad m => SpecialCon (m a) -> m (SpecialCon a)

Traversable ModuleName

Methods

traverse :: Applicative f => (a -> f b) -> ModuleName a -> f (ModuleName b)

sequenceA :: Applicative f => ModuleName (f a) -> f (ModuleName a)

mapM :: Monad m => (a -> m b) -> ModuleName a -> m (ModuleName b)

sequence :: Monad m => ModuleName (m a) -> m (ModuleName a)

Traversable FieldDecl

Methods

traverse :: Applicative f => (a -> f b) -> FieldDecl a -> f (FieldDecl b)

sequenceA :: Applicative f => FieldDecl (f a) -> f (FieldDecl a)

mapM :: Monad m => (a -> m b) -> FieldDecl a -> m (FieldDecl b)

sequence :: Monad m => FieldDecl (m a) -> m (FieldDecl a)

Traversable I

Methods

traverse :: Applicative f => (a -> f b) -> I a -> f (I b)

sequenceA :: Applicative f => I (f a) -> f (I a)

mapM :: Monad m => (a -> m b) -> I a -> m (I b)

sequence :: Monad m => I (m a) -> m (I a)

Traversable (Either a)

Methods

traverse :: Applicative f => (a -> f b) -> Either a a -> f (Either a b)

sequenceA :: Applicative f => Either a (f a) -> f (Either a a)

mapM :: Monad m => (a -> m b) -> Either a a -> m (Either a b)

sequence :: Monad m => Either a (m a) -> m (Either a a)

Traversable f => Traversable (Rec1 f)

Methods

traverse :: Applicative f => (a -> f b) -> Rec1 f a -> f (Rec1 f b)

sequenceA :: Applicative f => Rec1 f (f a) -> f (Rec1 f a)

mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b)

sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a)

Traversable (URec Char)

Methods

traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b)

sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a)

mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b)

sequence :: Monad m => URec Char (m a) -> m (URec Char a)

Traversable (URec Double)

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b)

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a)

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b)

sequence :: Monad m => URec Double (m a) -> m (URec Double a)

Traversable (URec Float)

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b)

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a)

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b)

sequence :: Monad m => URec Float (m a) -> m (URec Float a)

Traversable (URec Int)

Methods

traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b)

sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a)

mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b)

sequence :: Monad m => URec Int (m a) -> m (URec Int a)

Traversable (URec Word)

Methods

traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b)

sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a)

mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b)

sequence :: Monad m => URec Word (m a) -> m (URec Word a)

Traversable (URec (Ptr ()))

Methods

traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b)

sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)

mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b)

sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)

Traversable ((,) a)

Methods

traverse :: Applicative f => (a -> f b) -> (a, a) -> f (a, b)

sequenceA :: Applicative f => (a, f a) -> f (a, a)

mapM :: Monad m => (a -> m b) -> (a, a) -> m (a, b)

sequence :: Monad m => (a, m a) -> m (a, a)

Ix i => Traversable (Array i)

Methods

traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b)

sequenceA :: Applicative f => Array i (f a) -> f (Array i a)

mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b)

sequence :: Monad m => Array i (m a) -> m (Array i a)

Traversable (Arg a)

Methods

traverse :: Applicative f => (a -> f b) -> Arg a a -> f (Arg a b)

sequenceA :: Applicative f => Arg a (f a) -> f (Arg a a)

mapM :: Monad m => (a -> m b) -> Arg a a -> m (Arg a b)

sequence :: Monad m => Arg a (m a) -> m (Arg a a)

Traversable (Proxy *)

Methods

traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b)

sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a)

mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b)

sequence :: Monad m => Proxy * (m a) -> m (Proxy * a)

Traversable (Map k)

Methods

traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b)

sequenceA :: Applicative f => Map k (f a) -> f (Map k a)

mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b)

sequence :: Monad m => Map k (m a) -> m (Map k a)

Traversable f => Traversable (ListT f)

Methods

traverse :: Applicative f => (a -> f b) -> ListT f a -> f (ListT f b)

sequenceA :: Applicative f => ListT f (f a) -> f (ListT f a)

mapM :: Monad m => (a -> m b) -> ListT f a -> m (ListT f b)

sequence :: Monad m => ListT f (m a) -> m (ListT f a)

Traversable f => Traversable (MaybeT f)

Methods

traverse :: Applicative f => (a -> f b) -> MaybeT f a -> f (MaybeT f b)

sequenceA :: Applicative f => MaybeT f (f a) -> f (MaybeT f a)

mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b)

sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a)

Traversable (HashMap k)

Methods

traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b)

sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a)

mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b)

sequence :: Monad m => HashMap k (m a) -> m (HashMap k a)

Traversable (K a)

Methods

traverse :: Applicative f => (a -> f b) -> K a a -> f (K a b)

sequenceA :: Applicative f => K a (f a) -> f (K a a)

mapM :: Monad m => (a -> m b) -> K a a -> m (K a b)

sequence :: Monad m => K a (m a) -> m (K a a)

Traversable (NumMap k)

Methods

traverse :: Applicative f => (a -> f b) -> NumMap k a -> f (NumMap k b)

sequenceA :: Applicative f => NumMap k (f a) -> f (NumMap k a)

mapM :: Monad m => (a -> m b) -> NumMap k a -> m (NumMap k b)

sequence :: Monad m => NumMap k (m a) -> m (NumMap k a)

Traversable (K1 i c)

Methods

traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b)

sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a)

mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b)

sequence :: Monad m => K1 i c (m a) -> m (K1 i c a)

(Traversable f, Traversable g) => Traversable ((:+:) f g)

Methods

traverse :: Applicative f => (a -> f b) -> (f :+: g) a -> f ((f :+: g) b)

sequenceA :: Applicative f => (f :+: g) (f a) -> f ((f :+: g) a)

mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b)

sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a)

(Traversable f, Traversable g) => Traversable ((:*:) f g)

Methods

traverse :: Applicative f => (a -> f b) -> (f :*: g) a -> f ((f :*: g) b)

sequenceA :: Applicative f => (f :*: g) (f a) -> f ((f :*: g) a)

mapM :: Monad m => (a -> m b) -> (f :*: g) a -> m ((f :*: g) b)

sequence :: Monad m => (f :*: g) (m a) -> m ((f :*: g) a)

(Traversable f, Traversable g) => Traversable ((:.:) f g)

Methods

traverse :: Applicative f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b)

sequenceA :: Applicative f => (f :.: g) (f a) -> f ((f :.: g) a)

mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b)

sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a)

Traversable (Const * m)

Methods

traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b)

sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a)

mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b)

sequence :: Monad m => Const * m (m a) -> m (Const * m a)

Traversable f => Traversable (ErrorT e f)

Methods

traverse :: Applicative f => (a -> f b) -> ErrorT e f a -> f (ErrorT e f b)

sequenceA :: Applicative f => ErrorT e f (f a) -> f (ErrorT e f a)

mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b)

sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a)

Traversable f => Traversable (ExceptT e f)

Methods

traverse :: Applicative f => (a -> f b) -> ExceptT e f a -> f (ExceptT e f b)

sequenceA :: Applicative f => ExceptT e f (f a) -> f (ExceptT e f a)

mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b)

sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a)

Traversable f => Traversable (WriterT w f)

Methods

traverse :: Applicative f => (a -> f b) -> WriterT w f a -> f (WriterT w f b)

sequenceA :: Applicative f => WriterT w f (f a) -> f (WriterT w f a)

mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b)

sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a)

Traversable f => Traversable (WriterT w f)

Methods

traverse :: Applicative f => (a -> f b) -> WriterT w f a -> f (WriterT w f b)

sequenceA :: Applicative f => WriterT w f (f a) -> f (WriterT w f a)

mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b)

sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a)

Traversable f => Traversable (IdentityT * f)

Methods

traverse :: Applicative f => (a -> f b) -> IdentityT * f a -> f (IdentityT * f b)

sequenceA :: Applicative f => IdentityT * f (f a) -> f (IdentityT * f a)

mapM :: Monad m => (a -> m b) -> IdentityT * f a -> m (IdentityT * f b)

sequence :: Monad m => IdentityT * f (m a) -> m (IdentityT * f a)

Traversable f => Traversable (Cxt h f)

Methods

traverse :: Applicative f => (a -> f b) -> Cxt h f a -> f (Cxt h f b)

sequenceA :: Applicative f => Cxt h f (f a) -> f (Cxt h f a)

mapM :: Monad m => (a -> m b) -> Cxt h f a -> m (Cxt h f b)

sequence :: Monad m => Cxt h f (m a) -> m (Cxt h f a)

Traversable f => Traversable (M1 i c f)

Methods

traverse :: Applicative f => (a -> f b) -> M1 i c f a -> f (M1 i c f b)

sequenceA :: Applicative f => M1 i c f (f a) -> f (M1 i c f a)

mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b)

sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a)

(Traversable f, Traversable g) => Traversable (Sum * f g)

Methods

traverse :: Applicative f => (a -> f b) -> Sum * f g a -> f (Sum * f g b)

sequenceA :: Applicative f => Sum * f g (f a) -> f (Sum * f g a)

mapM :: Monad m => (a -> m b) -> Sum * f g a -> m (Sum * f g b)

sequence :: Monad m => Sum * f g (m a) -> m (Sum * f g a)

(Traversable f, Traversable g) => Traversable (Product * f g)

Methods

traverse :: Applicative f => (a -> f b) -> Product * f g a -> f (Product * f g b)

sequenceA :: Applicative f => Product * f g (f a) -> f (Product * f g a)

mapM :: Monad m => (a -> m b) -> Product * f g a -> m (Product * f g b)

sequence :: Monad m => Product * f g (m a) -> m (Product * f g a)

Traversable f => Traversable ((:&:) * f a)

Methods

traverse :: Applicative f => (a -> f b) -> (* :&: f) a a -> f ((* :&: f) a b)

sequenceA :: Applicative f => (* :&: f) a (f a) -> f ((* :&: f) a a)

mapM :: Monad m => (a -> m b) -> (* :&: f) a a -> m ((* :&: f) a b)

sequence :: Monad m => (* :&: f) a (m a) -> m ((* :&: f) a a)

(Traversable f, Traversable g) => Traversable ((:*:) * f g)

Methods

traverse :: Applicative f => (a -> f b) -> (* :*: f) g a -> f ((* :*: f) g b)

sequenceA :: Applicative f => (* :*: f) g (f a) -> f ((* :*: f) g a)

mapM :: Monad m => (a -> m b) -> (* :*: f) g a -> m ((* :*: f) g b)

sequence :: Monad m => (* :*: f) g (m a) -> m ((* :*: f) g a)

(Traversable f, Traversable g) => Traversable ((:+:) * f g)

Methods

traverse :: Applicative f => (a -> f b) -> (* :+: f) g a -> f ((* :+: f) g b)

sequenceA :: Applicative f => (* :+: f) g (f a) -> f ((* :+: f) g a)

mapM :: Monad m => (a -> m b) -> (* :+: f) g a -> m ((* :+: f) g b)

sequence :: Monad m => (* :+: f) g (m a) -> m ((* :+: f) g a)

(Traversable f, Traversable g) => Traversable (Compose * * f g)

Methods

traverse :: Applicative f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b)

sequenceA :: Applicative f => Compose * * f g (f a) -> f (Compose * * f g a)

mapM :: Monad m => (a -> m b) -> Compose * * f g a -> m (Compose * * f g b)

sequence :: Monad m => Compose * * f g (m a) -> m (Compose * * f g a)

makeTraversable :: Name -> Q [Dec]

Derive an instance of Traversable for a type constructor of any first-order kind taking at least one argument.

HaskellStrict

makeHaskellStrict :: Name -> Q [Dec]

Derive an instance of HaskellStrict for a type constructor of any first-order kind taking at least one argument.

haskellStrict :: (Monad m, HaskellStrict f, f :<: (m :+: g)) => f (TermT m g) -> TermT m g

haskellStrict' :: (Monad m, HaskellStrict f, f :<: (m :+: g)) => f (TermT m g) -> TermT m g

Arbitrary

class ArbitraryF f where

Signature arbitration. An instance ArbitraryF f gives rise to an instance Arbitrary (Term f).

Methods

arbitraryF' :: Arbitrary v => [(Int, Gen (f v))]

arbitraryF :: Arbitrary v => Gen (f v)

shrinkF :: Arbitrary v => f v -> [f v]

makeArbitraryF :: Name -> Q [Dec]

Derive an instance of ArbitraryF for a type constructor of any first-order kind taking at least one argument. It is necessary that all types that are used by the data type definition are themselves instances of Arbitrary.

class Arbitrary a where

Random generation and shrinking of values.

Minimal complete definition

arbitrary

Methods

arbitrary :: Gen a

A generator for values of the given type.

shrink :: a -> [a]

Produces a (possibly) empty list of all the possible immediate shrinks of the given value. The default implementation returns the empty list, so will not try to shrink the value.

Most implementations of shrink should try at least three things:

1. Shrink a term to any of its immediate subterms.
2. Recursively apply shrink to all immediate subterms.
3. Type-specific shrinkings such as replacing a constructor by a simpler constructor.

For example, suppose we have the following implementation of binary trees:

data Tree a = Nil | Branch a (Tree a) (Tree a)

We can then define shrink as follows:

shrink Nil = []
shrink (Branch x l r) =
  -- shrink Branch to Nil
  [Nil] ++
  -- shrink to subterms
  [l, r] ++
  -- recursively shrink subterms
  [Branch x' l' r' | (x', l', r') <- shrink (x, l, r)]

There are a couple of subtleties here:

• QuickCheck tries the shrinking candidates in the order they appear in the list, so we put more aggressive shrinking steps (such as replacing the whole tree by Nil) before smaller ones (such as recursively shrinking the subtrees).
• It is tempting to write the last line as [Branch x' l' r' | x' <- shrink x, l' <- shrink l, r' <- shrink r] but this is the wrong thing! It will force QuickCheck to shrink x, l and r in tandem, and shrinking will stop once one of the three is fully shrunk.

There is a fair bit of boilerplate in the code above. We can avoid it with the help of some generic functions; note that these only work on GHC 7.2 and above. The function genericShrink tries shrinking a term to all of its subterms and, failing that, recursively shrinks the subterms. Using it, we can define shrink as:

shrink x = shrinkToNil x ++ genericShrink x
  where
    shrinkToNil Nil = []
    shrinkToNil (Branch _ l r) = [Nil]

genericShrink is a combination of subterms, which shrinks a term to any of its subterms, and recursivelyShrink, which shrinks all subterms of a term. These may be useful if you need a bit more control over shrinking than genericShrink gives you.

A final gotcha: we cannot define shrink as simply shrink x = Nil:genericShrink x as this shrinks Nil to Nil, and shrinking will go into an infinite loop.

If all this leaves you bewildered, you might try shrink = genericShrink to begin with, after deriving Generic for your type. However, if your data type has any special invariants, you will need to check that genericShrink can't break those invariants.

Instances

Arbitrary Bool

Methods

arbitrary :: Gen Bool

shrink :: Bool -> [Bool]

Arbitrary Char

Methods

arbitrary :: Gen Char

shrink :: Char -> [Char]

Arbitrary Double

Methods

arbitrary :: Gen Double

shrink :: Double -> [Double]

Arbitrary Float

Methods

arbitrary :: Gen Float

shrink :: Float -> [Float]

Arbitrary Int

Methods

arbitrary :: Gen Int

shrink :: Int -> [Int]

Arbitrary Int8

Methods

arbitrary :: Gen Int8

shrink :: Int8 -> [Int8]

Arbitrary Int16

Methods

arbitrary :: Gen Int16

shrink :: Int16 -> [Int16]

Arbitrary Int32

Methods

arbitrary :: Gen Int32

shrink :: Int32 -> [Int32]

Arbitrary Int64

Methods

arbitrary :: Gen Int64

shrink :: Int64 -> [Int64]

Arbitrary Integer

Methods

arbitrary :: Gen Integer

shrink :: Integer -> [Integer]

Arbitrary Ordering

Methods

arbitrary :: Gen Ordering

shrink :: Ordering -> [Ordering]

Arbitrary Word

Methods

arbitrary :: Gen Word

shrink :: Word -> [Word]

Arbitrary Word8

Methods

arbitrary :: Gen Word8

shrink :: Word8 -> [Word8]

Arbitrary Word16

Methods

arbitrary :: Gen Word16

shrink :: Word16 -> [Word16]

Arbitrary Word32

Methods

arbitrary :: Gen Word32

shrink :: Word32 -> [Word32]

Arbitrary Word64

Methods

arbitrary :: Gen Word64

shrink :: Word64 -> [Word64]

Arbitrary ()

Methods

arbitrary :: Gen ()

shrink :: () -> [()]

Arbitrary Natural

Methods

arbitrary :: Gen Natural

shrink :: Natural -> [Natural]

Arbitrary IntSet

Methods

arbitrary :: Gen IntSet

shrink :: IntSet -> [IntSet]

Arbitrary a => Arbitrary [a]

Methods

arbitrary :: Gen [a]

shrink :: [a] -> [[a]]

Arbitrary a => Arbitrary (Maybe a)

Methods

arbitrary :: Gen (Maybe a)

shrink :: Maybe a -> [Maybe a]

Integral a => Arbitrary (Ratio a)

Methods

arbitrary :: Gen (Ratio a)

shrink :: Ratio a -> [Ratio a]

HasResolution a => Arbitrary (Fixed a)

Methods

arbitrary :: Gen (Fixed a)

shrink :: Fixed a -> [Fixed a]

(RealFloat a, Arbitrary a) => Arbitrary (Complex a)

Methods

arbitrary :: Gen (Complex a)

shrink :: Complex a -> [Complex a]

Arbitrary a => Arbitrary (IntMap a)

Methods

arbitrary :: Gen (IntMap a)

shrink :: IntMap a -> [IntMap a]

Arbitrary a => Arbitrary (Seq a)

Methods

arbitrary :: Gen (Seq a)

shrink :: Seq a -> [Seq a]

(Ord a, Arbitrary a) => Arbitrary (Set a)

Methods

arbitrary :: Gen (Set a)

shrink :: Set a -> [Set a]

(CoArbitrary a, Arbitrary b) => Arbitrary (a -> b)

Methods

arbitrary :: Gen (a -> b)

shrink :: (a -> b) -> [a -> b]

(Arbitrary a, Arbitrary b) => Arbitrary (Either a b)

Methods

arbitrary :: Gen (Either a b)

shrink :: Either a b -> [Either a b]

(Arbitrary a, Arbitrary b) => Arbitrary (a, b)

Methods

arbitrary :: Gen (a, b)

shrink :: (a, b) -> [(a, b)]

(Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map k v)

Methods

arbitrary :: Gen (Map k v)

shrink :: Map k v -> [Map k v]

(Arbitrary a, Arbitrary b, Arbitrary c) => Arbitrary (a, b, c)

Methods

arbitrary :: Gen (a, b, c)

shrink :: (a, b, c) -> [(a, b, c)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => Arbitrary (a, b, c, d)

Methods

arbitrary :: Gen (a, b, c, d)

shrink :: (a, b, c, d) -> [(a, b, c, d)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) => Arbitrary (a, b, c, d, e)

Methods

arbitrary :: Gen (a, b, c, d, e)

shrink :: (a, b, c, d, e) -> [(a, b, c, d, e)]

makeArbitrary :: Name -> Q [Dec]

Derive an instance of Arbitrary for a type constructor.

class NFData a where

A class of types that can be fully evaluated.

Since: 1.1.0.0

Methods

rnf :: a -> ()

rnf should reduce its argument to normal form (that is, fully evaluate all sub-components), and then return '()'.

Generic NFData deriving

Starting with GHC 7.2, you can automatically derive instances for types possessing a Generic instance.

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic)

instance NFData a => NFData (Foo a)

data Colour = Red | Green | Blue
              deriving Generic

instance NFData Colour

Starting with GHC 7.10, the example above can be written more concisely by enabling the new DeriveAnyClass extension:

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

import GHC.Generics (Generic)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, NFData)

data Colour = Red | Green | Blue
              deriving (Generic, NFData)

Compatibility with previous deepseq versions

Prior to version 1.4.0.0, the default implementation of the rnf method was defined as

rnf a = seq a ()

However, starting with deepseq-1.4.0.0, the default implementation is based on DefaultSignatures allowing for more accurate auto-derived NFData instances. If you need the previously used exact default rnf method implementation semantics, use

instance NFData Colour where rnf x = seq x ()

or alternatively

{-# LANGUAGE BangPatterns #-}
instance NFData Colour where rnf !_ = ()

Instances

NFData Bool

Methods

rnf :: Bool -> ()

NFData Char

Methods

rnf :: Char -> ()

NFData Double

Methods

rnf :: Double -> ()

NFData Float

Methods

rnf :: Float -> ()

NFData Int

Methods

rnf :: Int -> ()

NFData Int8

Methods

rnf :: Int8 -> ()

NFData Int16

Methods

rnf :: Int16 -> ()

NFData Int32

Methods

rnf :: Int32 -> ()

NFData Int64

Methods

rnf :: Int64 -> ()

NFData Integer

Methods

rnf :: Integer -> ()

NFData Word

Methods

rnf :: Word -> ()

NFData Word8

Methods

rnf :: Word8 -> ()

NFData Word16

Methods

rnf :: Word16 -> ()

NFData Word32

Methods

rnf :: Word32 -> ()

NFData Word64

Methods

rnf :: Word64 -> ()

NFData CallStack

Since: 1.4.2.0

Methods

rnf :: CallStack -> ()

NFData TypeRep

NOTE: Only defined for base-4.8.0.0 and later

Since: 1.4.0.0

Methods

rnf :: TypeRep -> ()

NFData ()

Methods

rnf :: () -> ()

NFData TyCon

NOTE: Only defined for base-4.8.0.0 and later

Since: 1.4.0.0

Methods

rnf :: TyCon -> ()

NFData Natural

Since: 1.4.0.0

Methods

rnf :: Natural -> ()

NFData Void

Defined as rnf = absurd.

Since: 1.4.0.0

Methods

rnf :: Void -> ()

NFData Version

Since: 1.3.0.0

Methods

rnf :: Version -> ()

NFData Unique

Since: 1.4.0.0

Methods

rnf :: Unique -> ()

NFData ThreadId

Since: 1.4.0.0

Methods

rnf :: ThreadId -> ()

NFData ExitCode

Since: 1.4.2.0

Methods

rnf :: ExitCode -> ()

NFData CChar

Since: 1.4.0.0

Methods

rnf :: CChar -> ()

NFData CSChar

Since: 1.4.0.0

Methods

rnf :: CSChar -> ()

NFData CUChar

Since: 1.4.0.0

Methods

rnf :: CUChar -> ()

NFData CShort

Since: 1.4.0.0

Methods

rnf :: CShort -> ()

NFData CUShort

Since: 1.4.0.0

Methods

rnf :: CUShort -> ()

NFData CInt

Since: 1.4.0.0

Methods

rnf :: CInt -> ()

NFData CUInt

Since: 1.4.0.0

Methods

rnf :: CUInt -> ()

NFData CLong

Since: 1.4.0.0

Methods

rnf :: CLong -> ()

NFData CULong

Since: 1.4.0.0

Methods

rnf :: CULong -> ()

NFData CLLong

Since: 1.4.0.0

Methods

rnf :: CLLong -> ()

NFData CULLong

Since: 1.4.0.0

Methods

rnf :: CULLong -> ()

NFData CFloat

Since: 1.4.0.0

Methods

rnf :: CFloat -> ()

NFData CDouble

Since: 1.4.0.0

Methods

rnf :: CDouble -> ()

NFData CPtrdiff

Since: 1.4.0.0

Methods

rnf :: CPtrdiff -> ()

NFData CSize

Since: 1.4.0.0

Methods

rnf :: CSize -> ()

NFData CWchar

Since: 1.4.0.0

Methods

rnf :: CWchar -> ()

NFData CSigAtomic

Since: 1.4.0.0

Methods

rnf :: CSigAtomic -> ()

NFData CClock

Since: 1.4.0.0

Methods

rnf :: CClock -> ()

NFData CTime

Since: 1.4.0.0

Methods

rnf :: CTime -> ()

NFData CUSeconds

Since: 1.4.0.0

Methods

rnf :: CUSeconds -> ()

NFData CSUSeconds

Since: 1.4.0.0

Methods

rnf :: CSUSeconds -> ()

NFData CFile

Since: 1.4.0.0

Methods

rnf :: CFile -> ()

NFData CFpos

Since: 1.4.0.0

Methods

rnf :: CFpos -> ()

NFData CJmpBuf

Since: 1.4.0.0

Methods

rnf :: CJmpBuf -> ()

NFData CIntPtr

Since: 1.4.0.0

Methods

rnf :: CIntPtr -> ()

NFData CUIntPtr

Since: 1.4.0.0

Methods

rnf :: CUIntPtr -> ()

NFData CIntMax

Since: 1.4.0.0

Methods

rnf :: CIntMax -> ()

NFData CUIntMax

Since: 1.4.0.0

Methods

rnf :: CUIntMax -> ()

NFData All

Since: 1.4.0.0

Methods

rnf :: All -> ()

NFData Any

Since: 1.4.0.0

Methods

rnf :: Any -> ()

NFData Fingerprint

Since: 1.4.0.0

Methods

rnf :: Fingerprint -> ()

NFData SrcLoc

Since: 1.4.2.0

Methods

rnf :: SrcLoc -> ()

NFData IntSet

Methods

rnf :: IntSet -> ()

NFData Doc

Methods

rnf :: Doc -> ()

NFData TextDetails

Methods

rnf :: TextDetails -> ()

NFData LocalTime

Methods

rnf :: LocalTime -> ()

NFData ZonedTime

Methods

rnf :: ZonedTime -> ()

NFData a => NFData [a]

Methods

rnf :: [a] -> ()

NFData a => NFData (Maybe a)

Methods

rnf :: Maybe a -> ()

NFData a => NFData (Ratio a)

Methods

rnf :: Ratio a -> ()

NFData (Ptr a)

Since: 1.4.2.0

Methods

rnf :: Ptr a -> ()

NFData (FunPtr a)

Since: 1.4.2.0

Methods

rnf :: FunPtr a -> ()

NFData a => NFData (Identity a)

Since: 1.4.0.0

Methods

rnf :: Identity a -> ()

NFData a => NFData (Min a)

Since: 1.4.2.0

Methods

rnf :: Min a -> ()

NFData a => NFData (Max a)

Since: 1.4.2.0

Methods

rnf :: Max a -> ()

NFData a => NFData (First a)

Since: 1.4.2.0

Methods

rnf :: First a -> ()

NFData a => NFData (Last a)

Since: 1.4.2.0

Methods

rnf :: Last a -> ()

NFData m => NFData (WrappedMonoid m)

Since: 1.4.2.0

Methods

rnf :: WrappedMonoid m -> ()

NFData a => NFData (Option a)

Since: 1.4.2.0

Methods

rnf :: Option a -> ()

NFData a => NFData (NonEmpty a)

Since: 1.4.2.0

Methods

rnf :: NonEmpty a -> ()

NFData (Fixed a)

Since: 1.3.0.0

Methods

rnf :: Fixed a -> ()

NFData a => NFData (Complex a)

Methods

rnf :: Complex a -> ()

NFData (StableName a)

Since: 1.4.0.0

Methods

rnf :: StableName a -> ()

NFData a => NFData (ZipList a)

Since: 1.4.0.0

Methods

rnf :: ZipList a -> ()

NFData a => NFData (Dual a)

Since: 1.4.0.0

Methods

rnf :: Dual a -> ()

NFData a => NFData (Sum a)

Since: 1.4.0.0

Methods

rnf :: Sum a -> ()

NFData a => NFData (Product a)

Since: 1.4.0.0

Methods

rnf :: Product a -> ()

NFData a => NFData (First a)

Since: 1.4.0.0

Methods

rnf :: First a -> ()

NFData a => NFData (Last a)

Since: 1.4.0.0

Methods

rnf :: Last a -> ()

NFData (IORef a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: IORef a -> ()

NFData a => NFData (Down a)

Since: 1.4.0.0

Methods

rnf :: Down a -> ()

NFData (MVar a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: MVar a -> ()

NFData a => NFData (Digit a)

Methods

rnf :: Digit a -> ()

NFData a => NFData (Node a)

Methods

rnf :: Node a -> ()

NFData a => NFData (Elem a)

Methods

rnf :: Elem a -> ()

NFData a => NFData (FingerTree a)

Methods

rnf :: FingerTree a -> ()

NFData a => NFData (IntMap a)

Methods

rnf :: IntMap a -> ()

NFData a => NFData (Tree a)

Methods

rnf :: Tree a -> ()

NFData a => NFData (Seq a)

Methods

rnf :: Seq a -> ()

NFData a => NFData (Set a)

Methods

rnf :: Set a -> ()

NFData a => NFData (Doc a)

Methods

rnf :: Doc a -> ()

NFData a => NFData (AnnotDetails a)

Methods

rnf :: AnnotDetails a -> ()

NFData a => NFData (HashSet a)

Methods

rnf :: HashSet a -> ()

NFData (a -> b)

This instance is for convenience and consistency with seq. This assumes that WHNF is equivalent to NF for functions.

Since: 1.3.0.0

Methods

rnf :: (a -> b) -> ()

(NFData a, NFData b) => NFData (Either a b)

Methods

rnf :: Either a b -> ()

(NFData a, NFData b) => NFData (a, b)

Methods

rnf :: (a, b) -> ()

(NFData a, NFData b) => NFData (Array a b)

Methods

rnf :: Array a b -> ()

(NFData a, NFData b) => NFData (Arg a b)

Since: 1.4.2.0

Methods

rnf :: Arg a b -> ()

NFData (Proxy k a)

Since: 1.4.0.0

Methods

rnf :: Proxy k a -> ()

NFData (STRef s a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: STRef s a -> ()

(NFData k, NFData a) => NFData (Map k a)

Methods

rnf :: Map k a -> ()

(NFData k, NFData v) => NFData (Leaf k v)

Methods

rnf :: Leaf k v -> ()

(NFData k, NFData v) => NFData (HashMap k v)

Methods

rnf :: HashMap k v -> ()

(NFData a, NFData b, NFData c) => NFData (a, b, c)

Methods

rnf :: (a, b, c) -> ()

NFData a => NFData (Const k a b)

Since: 1.4.0.0

Methods

rnf :: Const k a b -> ()

(NFData a, NFData b, NFData c, NFData d) => NFData (a, b, c, d)

Methods

rnf :: (a, b, c, d) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5)

Methods

rnf :: (a1, a2, a3, a4, a5) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6) => NFData (a1, a2, a3, a4, a5, a6)

Methods

rnf :: (a1, a2, a3, a4, a5, a6) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7) => NFData (a1, a2, a3, a4, a5, a6, a7)

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8) => NFData (a1, a2, a3, a4, a5, a6, a7, a8)

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7, a8) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8, NFData a9) => NFData (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ()

makeNFData :: Name -> Q [Dec]

Derive an instance of NFData for a type constructor.

DeepSeq

class NFDataF f where

Signature normal form. An instance NFDataF f gives rise to an instance NFData (Term f).

Minimal complete definition

rnfF

Methods

rnfF :: NFData a => f a -> ()

makeNFDataF :: Name -> Q [Dec]

Derive an instance of NFDataF for a type constructor of any first-order kind taking at least one argument.

Smart Constructors

smartConstructors :: Name -> Q [Dec]

Derive smart constructors for a type constructor of any first-order kind taking at least one argument. The smart constructors are similar to the ordinary constructors, but an inject is automatically inserted.

Smart Constructors w/ Annotations

smartAConstructors :: Name -> Q [Dec]

Derive smart constructors with products for a type constructor of any parametric kind taking at least one argument. The smart constructors are similar to the ordinary constructors, but an injectA is automatically inserted.

Lifting to Sums

liftSum :: Name -> Q [Dec]

Given the name of a type class, where the first parameter is a functor, lift it to sums of functors. Example: class ShowF f where ... is lifted as instance (ShowF f, ShowF g) => ShowF (f :+: g) where ... .