Safe Haskell  None 

Language  Haskell2010 
Synopsis
 data SnocList a
 data SnocList1 a
 data List1 a
 data Maybe' a
 maybe' :: b > (a > b) > Maybe' a > b
 data Pair' a b = Pair' !a !b
 newtype N a s = N {
 runN :: a
 newtype S a s = S {
 runS :: a
 data Tree a
 data Tree1 a
 newtype An a = An a
 data Box a = Box a
 newtype FreeMonoid a = FreeMonoid {
 runFreeMonoid :: forall m. Monoid m => (a > m) > m
 foldDeRef :: forall f a. (MuRef1 f, Bifoldable (DeRef1 f)) => f a > FreeMonoid a
 newtype FreeSemigroup a = FreeSemigroup {
 runFreeSemigroup :: forall m. Semigroup m => (a > m) > m
 foldDeRef1 :: forall f a. (MuRef1 f, Bifoldable1 (DeRef1 f)) => f a > FreeSemigroup a
Documentation
Reversed '[]'
Instances
Functor SnocList Source #  
Foldable SnocList Source #  
Defined in Data.Fold.Internal fold :: Monoid m => SnocList m > m # foldMap :: Monoid m => (a > m) > SnocList a > m # foldMap' :: Monoid m => (a > m) > SnocList a > m # foldr :: (a > b > b) > b > SnocList a > b # foldr' :: (a > b > b) > b > SnocList a > b # foldl :: (b > a > b) > b > SnocList a > b # foldl' :: (b > a > b) > b > SnocList a > b # foldr1 :: (a > a > a) > SnocList a > a # foldl1 :: (a > a > a) > SnocList a > a # elem :: Eq a => a > SnocList a > Bool # maximum :: Ord a => SnocList a > a # minimum :: Ord a => SnocList a > a #  
Traversable SnocList Source #  
Eq a => Eq (SnocList a) Source #  
Data a => Data (SnocList a) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > SnocList a > c (SnocList a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (SnocList a) # toConstr :: SnocList a > Constr # dataTypeOf :: SnocList a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (SnocList a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (SnocList a)) # gmapT :: (forall b. Data b => b > b) > SnocList a > SnocList a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > SnocList a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > SnocList a > r # gmapQ :: (forall d. Data d => d > u) > SnocList a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > SnocList a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > SnocList a > m (SnocList a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > SnocList a > m (SnocList a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > SnocList a > m (SnocList a) #  
Ord a => Ord (SnocList a) Source #  
Read a => Read (SnocList a) Source #  
Show a => Show (SnocList a) Source #  
Instances
Functor SnocList1 Source #  
Foldable SnocList1 Source #  
Defined in Data.Fold.Internal fold :: Monoid m => SnocList1 m > m # foldMap :: Monoid m => (a > m) > SnocList1 a > m # foldMap' :: Monoid m => (a > m) > SnocList1 a > m # foldr :: (a > b > b) > b > SnocList1 a > b # foldr' :: (a > b > b) > b > SnocList1 a > b # foldl :: (b > a > b) > b > SnocList1 a > b # foldl' :: (b > a > b) > b > SnocList1 a > b # foldr1 :: (a > a > a) > SnocList1 a > a # foldl1 :: (a > a > a) > SnocList1 a > a # toList :: SnocList1 a > [a] # length :: SnocList1 a > Int # elem :: Eq a => a > SnocList1 a > Bool # maximum :: Ord a => SnocList1 a > a # minimum :: Ord a => SnocList1 a > a #  
Traversable SnocList1 Source #  
Eq a => Eq (SnocList1 a) Source #  
Data a => Data (SnocList1 a) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > SnocList1 a > c (SnocList1 a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (SnocList1 a) # toConstr :: SnocList1 a > Constr # dataTypeOf :: SnocList1 a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (SnocList1 a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (SnocList1 a)) # gmapT :: (forall b. Data b => b > b) > SnocList1 a > SnocList1 a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > SnocList1 a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > SnocList1 a > r # gmapQ :: (forall d. Data d => d > u) > SnocList1 a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > SnocList1 a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > SnocList1 a > m (SnocList1 a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > SnocList1 a > m (SnocList1 a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > SnocList1 a > m (SnocList1 a) #  
Ord a => Ord (SnocList1 a) Source #  
Defined in Data.Fold.Internal  
Read a => Read (SnocList1 a) Source #  
Show a => Show (SnocList1 a) Source #  
Instances
Functor List1 Source #  
Foldable List1 Source #  
Defined in Data.Fold.Internal fold :: Monoid m => List1 m > m # foldMap :: Monoid m => (a > m) > List1 a > m # foldMap' :: Monoid m => (a > m) > List1 a > m # foldr :: (a > b > b) > b > List1 a > b # foldr' :: (a > b > b) > b > List1 a > b # foldl :: (b > a > b) > b > List1 a > b # foldl' :: (b > a > b) > b > List1 a > b # foldr1 :: (a > a > a) > List1 a > a # foldl1 :: (a > a > a) > List1 a > a # elem :: Eq a => a > List1 a > Bool # maximum :: Ord a => List1 a > a # minimum :: Ord a => List1 a > a #  
Traversable List1 Source #  
Strict Maybe
Instances
Foldable Maybe' Source #  
Defined in Data.Fold.Internal fold :: Monoid m => Maybe' m > m # foldMap :: Monoid m => (a > m) > Maybe' a > 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 # elem :: Eq a => a > Maybe' a > Bool # maximum :: Ord a => Maybe' a > a # minimum :: Ord a => Maybe' a > a #  
Eq a => Eq (Maybe' a) Source #  
Data a => Data (Maybe' a) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > Maybe' a > c (Maybe' a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (Maybe' a) # toConstr :: Maybe' a > Constr # dataTypeOf :: Maybe' a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (Maybe' a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (Maybe' a)) # gmapT :: (forall b. Data b => b > b) > Maybe' a > Maybe' a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Maybe' a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Maybe' a > r # gmapQ :: (forall d. Data d => d > u) > Maybe' a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Maybe' a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Maybe' a > m (Maybe' a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Maybe' a > m (Maybe' a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Maybe' a > m (Maybe' a) #  
Ord a => Ord (Maybe' a) Source #  
Defined in Data.Fold.Internal  
Read a => Read (Maybe' a) Source #  
Show a => Show (Maybe' a) Source #  
Strict Pair
Pair' !a !b 
Instances
(Eq a, Eq b) => Eq (Pair' a b) Source #  
(Data a, Data b) => Data (Pair' a b) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b0. Data d => c (d > b0) > d > c b0) > (forall g. g > c g) > Pair' a b > c (Pair' a b) # gunfold :: (forall b0 r. Data b0 => c (b0 > r) > c r) > (forall r. r > c r) > Constr > c (Pair' a b) # toConstr :: Pair' a b > Constr # dataTypeOf :: Pair' a b > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (Pair' a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (Pair' a b)) # gmapT :: (forall b0. Data b0 => b0 > b0) > Pair' a b > Pair' a b # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Pair' a b > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Pair' a b > r # gmapQ :: (forall d. Data d => d > u) > Pair' a b > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Pair' a b > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Pair' a b > m (Pair' a b) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Pair' a b > m (Pair' a b) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Pair' a b > m (Pair' a b) #  
(Ord a, Ord b) => Ord (Pair' a b) Source #  
Defined in Data.Fold.Internal  
(Read a, Read b) => Read (Pair' a b) Source #  
(Show a, Show b) => Show (Pair' a b) Source #  
(Semigroup a, Semigroup b) => Semigroup (Pair' a b) Source #  
(Monoid a, Monoid b) => Monoid (Pair' a b) Source #  
A reified Monoid
.
Instances
Eq a => Eq (N a s) Source #  
(Data a, Data s) => Data (N a s) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > N a s > c (N a s) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (N a s) # dataTypeOf :: N a s > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (N a s)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (N a s)) # gmapT :: (forall b. Data b => b > b) > N a s > N a s # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > N a s > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > N a s > r # gmapQ :: (forall d. Data d => d > u) > N a s > [u] # gmapQi :: Int > (forall d. Data d => d > u) > N a s > u # gmapM :: Monad m => (forall d. Data d => d > m d) > N a s > m (N a s) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > N a s > m (N a s) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > N a s > m (N a s) #  
Ord a => Ord (N a s) Source #  
Read a => Read (N a s) Source #  
Show a => Show (N a s) Source #  
Reifies s (a > a > a, a) => Semigroup (N a s) Source #  
Reifies s (a > a > a, a) => Monoid (N a s) Source #  
A reified Semigroup
.
Instances
Eq a => Eq (S a s) Source #  
(Data a, Data s) => Data (S a s) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > S a s > c (S a s) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (S a s) # dataTypeOf :: S a s > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (S a s)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (S a s)) # gmapT :: (forall b. Data b => b > b) > S a s > S a s # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > S a s > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > S a s > r # gmapQ :: (forall d. Data d => d > u) > S a s > [u] # gmapQi :: Int > (forall d. Data d => d > u) > S a s > u # gmapM :: Monad m => (forall d. Data d => d > m d) > S a s > m (S a s) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > S a s > m (S a s) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > S a s > m (S a s) #  
Ord a => Ord (S a s) Source #  
Read a => Read (S a s) Source #  
Show a => Show (S a s) Source #  
Reifies s (a > a > a) => Semigroup (S a s) Source #  
The shape of a foldMap
Instances
Functor Tree Source #  
Foldable Tree Source #  
Defined in Data.Fold.Internal fold :: Monoid m => Tree m > m # foldMap :: Monoid m => (a > m) > Tree a > 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 # elem :: Eq a => a > Tree a > Bool # maximum :: Ord a => Tree a > a #  
Traversable Tree Source #  
Eq a => Eq (Tree a) Source #  
Data a => Data (Tree a) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > Tree a > c (Tree a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (Tree a) # toConstr :: Tree a > Constr # dataTypeOf :: Tree a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (Tree a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (Tree a)) # gmapT :: (forall b. Data b => b > b) > Tree a > Tree a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Tree a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Tree a > r # gmapQ :: (forall d. Data d => d > u) > Tree a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Tree a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Tree a > m (Tree a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Tree a > m (Tree a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Tree a > m (Tree a) #  
Ord a => Ord (Tree a) Source #  
Read a => Read (Tree a) Source #  
Show a => Show (Tree a) Source #  
MuRef (Tree a) Source #  
type DeRef (Tree a) Source #  
Defined in Data.Fold.Internal 
Instances
Functor Tree1 Source #  
Foldable Tree1 Source #  
Defined in Data.Fold.Internal fold :: Monoid m => Tree1 m > m # foldMap :: Monoid m => (a > m) > Tree1 a > m # foldMap' :: Monoid m => (a > m) > Tree1 a > m # foldr :: (a > b > b) > b > Tree1 a > b # foldr' :: (a > b > b) > b > Tree1 a > b # foldl :: (b > a > b) > b > Tree1 a > b # foldl' :: (b > a > b) > b > Tree1 a > b # foldr1 :: (a > a > a) > Tree1 a > a # foldl1 :: (a > a > a) > Tree1 a > a # elem :: Eq a => a > Tree1 a > Bool # maximum :: Ord a => Tree1 a > a # minimum :: Ord a => Tree1 a > a #  
Traversable Tree1 Source #  
MuRef (Tree1 a) Source #  
type DeRef (Tree1 a) Source #  
Defined in Data.Fold.Internal 
An a 
Instances
Functor An Source #  
Foldable An Source #  
Defined in Data.Fold.Internal fold :: Monoid m => An m > m # foldMap :: Monoid m => (a > m) > An a > m # foldMap' :: Monoid m => (a > m) > An a > m # foldr :: (a > b > b) > b > An a > b # foldr' :: (a > b > b) > b > An a > b # foldl :: (b > a > b) > b > An a > b # foldl' :: (b > a > b) > b > An a > b # foldr1 :: (a > a > a) > An a > a # foldl1 :: (a > a > a) > An a > a # elem :: Eq a => a > An a > Bool # maximum :: Ord a => An a > a #  
Traversable An Source #  
Eq a => Eq (An a) Source #  
Data a => Data (An a) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > An a > c (An a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (An a) # dataTypeOf :: An a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (An a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (An a)) # gmapT :: (forall b. Data b => b > b) > An a > An a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > An a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > An a > r # gmapQ :: (forall d. Data d => d > u) > An a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > An a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > An a > m (An a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > An a > m (An a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > An a > m (An a) #  
Ord a => Ord (An a) Source #  
Read a => Read (An a) Source #  
Show a => Show (An a) Source #  
Box a 
Instances
Functor Box Source #  
Foldable Box Source #  
Defined in Data.Fold.Internal fold :: Monoid m => Box m > m # foldMap :: Monoid m => (a > m) > Box a > m # foldMap' :: Monoid m => (a > m) > Box a > m # foldr :: (a > b > b) > b > Box a > b # foldr' :: (a > b > b) > b > Box a > b # foldl :: (b > a > b) > b > Box a > b # foldl' :: (b > a > b) > b > Box a > b # foldr1 :: (a > a > a) > Box a > a # foldl1 :: (a > a > a) > Box a > a # elem :: Eq a => a > Box a > Bool # maximum :: Ord a => Box a > a #  
Traversable Box Source #  
Eq a => Eq (Box a) Source #  
Data a => Data (Box a) Source #  
Defined in Data.Fold.Internal gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > Box a > c (Box a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (Box a) # dataTypeOf :: Box a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (Box a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (Box a)) # gmapT :: (forall b. Data b => b > b) > Box a > Box a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Box a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Box a > r # gmapQ :: (forall d. Data d => d > u) > Box a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Box a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Box a > m (Box a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Box a > m (Box a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Box a > m (Box a) #  
Ord a => Ord (Box a) Source #  
Read a => Read (Box a) Source #  
Show a => Show (Box a) Source #  
newtype FreeMonoid a Source #
FreeMonoid  

Instances
foldDeRef :: forall f a. (MuRef1 f, Bifoldable (DeRef1 f)) => f a > FreeMonoid a Source #
newtype FreeSemigroup a Source #
FreeSemigroup  

Instances
foldDeRef1 :: forall f a. (MuRef1 f, Bifoldable1 (DeRef1 f)) => f a > FreeSemigroup a Source #