Data.Parameterized.TraversableF

This module declares classes for working with structures that accept a single parametric type parameter.

Documentation

class FunctorF m where

A parameterized type that is a function on all instances.

Minimal complete definition

fmapF

Methods

fmapF :: (forall x. f x -> g x) -> m f -> m g

Instances

FunctorF k (Const (k -> *) x)

Methods

fmapF :: (forall (a :: Const (k -> *) x). f a -> g a) -> m f -> m g

FunctorF k (Pair k a)

Methods

fmapF :: (forall (x :: Pair k a). f x -> g x) -> m f -> m g

FunctorF k (MapF k ktp)

Methods

fmapF :: (forall (x :: MapF k ktp). f x -> g x) -> m f -> m g

class FoldableF (t :: (k -> *) -> *) where

This is a generalization of the Foldable class to structures over parameterized terms.

Minimal complete definition

foldMapF | foldrF

Methods

foldMapF :: Monoid m => (forall s. e s -> m) -> t e -> m

Map each element of the structure to a monoid, and combine the results.

foldrF :: (forall s. e s -> b -> b) -> b -> t e -> b

Right-associative fold of a structure.

foldlF :: (forall s. b -> e s -> b) -> b -> t e -> b

Left-associative fold of a structure.

foldrF' :: (forall s. e s -> b -> b) -> b -> t e -> b

Right-associative fold of a structure, but with strict application of the operator.

foldlF' :: (forall s. b -> e s -> b) -> b -> t e -> b

Left-associative fold of a parameterized structure with a strict accumulator.

toListF :: (forall tp. f tp -> a) -> t f -> [a]

Convert structure to list.

Instances

FoldableF k (Const (k -> *) x)

Methods

foldMapF :: Monoid m => (forall (s :: Const (k -> *) x). e s -> m) -> t e -> m

foldrF :: (forall (s :: Const (k -> *) x). e s -> b -> b) -> b -> t e -> b

foldlF :: (forall (s :: Const (k -> *) x). b -> e s -> b) -> b -> t e -> b

foldrF' :: (forall (s :: Const (k -> *) x). e s -> b -> b) -> b -> t e -> b

foldlF' :: (forall (s :: Const (k -> *) x). b -> e s -> b) -> b -> t e -> b

toListF :: (forall (tp :: Const (k -> *) x). f tp -> a) -> t f -> [a]

FoldableF k (Pair k a)

Methods

foldMapF :: Monoid m => (forall (s :: Pair k a). e s -> m) -> t e -> m

foldrF :: (forall (s :: Pair k a). e s -> b -> b) -> b -> t e -> b

foldlF :: (forall (s :: Pair k a). b -> e s -> b) -> b -> t e -> b

foldrF' :: (forall (s :: Pair k a). e s -> b -> b) -> b -> t e -> b

foldlF' :: (forall (s :: Pair k a). b -> e s -> b) -> b -> t e -> b

toListF :: (forall (tp :: Pair k a). f tp -> a) -> t f -> [a]

FoldableF k (MapF k ktp)

Methods

foldMapF :: Monoid m => (forall (s :: MapF k ktp). e s -> m) -> t e -> m

foldrF :: (forall (s :: MapF k ktp). e s -> b -> b) -> b -> t e -> b

foldlF :: (forall (s :: MapF k ktp). b -> e s -> b) -> b -> t e -> b

foldrF' :: (forall (s :: MapF k ktp). e s -> b -> b) -> b -> t e -> b

foldlF' :: (forall (s :: MapF k ktp). b -> e s -> b) -> b -> t e -> b

toListF :: (forall (tp :: MapF k ktp). f tp -> a) -> t f -> [a]

class (FunctorF t, FoldableF t) => TraversableF t where

Minimal complete definition

traverseF

Methods

traverseF :: Applicative m => (forall s. e s -> m (f s)) -> t e -> m (t f)

Instances

TraversableF k (Const (k -> *) x)

Methods

traverseF :: Applicative m => (forall (s :: Const (k -> *) x). e s -> m (f s)) -> t e -> m (t f)

TraversableF k (MapF k ktp)

Methods

traverseF :: Applicative m => (forall (s :: MapF k ktp). e s -> m (f s)) -> t e -> m (t f)

traverseF_ :: (FoldableF t, Applicative f) => (forall s. e s -> f ()) -> t e -> f ()

Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results.

fmapFDefault :: TraversableF t => (forall s. e s -> f s) -> t e -> t f

This function may be used as a value for fmapF in a FunctorF instance.

foldMapFDefault :: (TraversableF t, Monoid m) => (forall s. e s -> m) -> t e -> m

This function may be used as a value for foldMap in a Foldable instance.

allF :: FoldableF t => (forall tp. f tp -> Bool) -> t f -> Bool

Return True if all values satisfy predicate.

anyF :: FoldableF t => (forall tp. f tp -> Bool) -> t f -> Bool

Return True if any values satisfy predicate.