Data.Parameterized.TraversableF

Description : Traversing structures having a single parametric type

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 functor on all instances.

Methods

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

Instances

FunctorF (Some :: (k -> Type) -> Type)

Defined in Data.Parameterized.Some

Methods

fmapF :: (forall (x :: k0). f x -> g x) -> Some f -> Some g

FunctorF (All :: (k -> Type) -> Type)

Defined in Data.Parameterized.All

Methods

fmapF :: (forall (x :: k0). f x -> g x) -> All f -> All g

FunctorF (Const x :: (k -> Type) -> Type)

Defined in Data.Parameterized.TraversableF

Methods

fmapF :: (forall (x0 :: k0). f x0 -> g x0) -> Const x f -> Const x g

FunctorF (Pair a :: (k -> Type) -> Type)

Defined in Data.Parameterized.Pair

Methods

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

FunctorF (MapF ktp :: (k -> Type) -> Type)

Defined in Data.Parameterized.Map

Methods

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

(FunctorF s, FunctorFC t) => FunctorF (Compose s t :: (l -> Type) -> Type)

Defined in Data.Parameterized.TraversableF

Methods

fmapF :: (forall (x :: k). f x -> g x) -> Compose s t f -> Compose s t 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 (Some :: (k -> Type) -> Type)

Defined in Data.Parameterized.Some

Methods

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

foldrF :: (forall (s :: k0). e s -> b -> b) -> b -> Some e -> b

foldlF :: (forall (s :: k0). b -> e s -> b) -> b -> Some e -> b

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

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

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

FoldableF (All :: (k -> Type) -> Type)

Defined in Data.Parameterized.All

Methods

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

foldrF :: (forall (s :: k0). e s -> b -> b) -> b -> All e -> b

foldlF :: (forall (s :: k0). b -> e s -> b) -> b -> All e -> b

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

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

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

FoldableF (Const x :: (k -> Type) -> Type)

Defined in Data.Parameterized.TraversableF

Methods

foldMapF :: Monoid m => (forall (s :: k0). e s -> m) -> Const x e -> m

foldrF :: (forall (s :: k0). e s -> b -> b) -> b -> Const x e -> b

foldlF :: (forall (s :: k0). b -> e s -> b) -> b -> Const x e -> b

foldrF' :: (forall (s :: k0). e s -> b -> b) -> b -> Const x e -> b

foldlF' :: (forall (s :: k0). b -> e s -> b) -> b -> Const x e -> b

toListF :: (forall (tp :: k0). f tp -> a) -> Const x f -> [a]

FoldableF (Pair a :: (k -> Type) -> Type)

Defined in Data.Parameterized.Pair

Methods

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

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

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

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

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

toListF :: (forall (tp :: k0). f tp -> a0) -> Pair a f -> [a0]

FoldableF (MapF ktp :: (k -> Type) -> Type)

Defined in Data.Parameterized.Map

Methods

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

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

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

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

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

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

(TraversableF s, TraversableFC t) => FoldableF (Compose s t :: (l -> Type) -> Type)

Defined in Data.Parameterized.TraversableF

Methods

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

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

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

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

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

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

foldlMF :: (FoldableF t, Monad m) => (forall x. b -> f x -> m b) -> b -> t f -> m b

Monadic fold over the elements of a structure from left to right.

foldlMF' :: (FoldableF t, Monad m) => (forall x. b -> f x -> m b) -> b -> t f -> m b

Monadic strict fold over the elements of a structure from left to right.

foldrMF :: (FoldableF t, Monad m) => (forall x. f x -> b -> m b) -> b -> t f -> m b

Monadic fold over the elements of a structure from right to left.

foldrMF' :: (FoldableF t, Monad m) => (forall x. f x -> b -> m b) -> b -> t f -> m b

Monadic strict fold over the elements of a structure from right to left.

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

Methods

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

Instances

TraversableF (Some :: (k -> Type) -> Type)

Defined in Data.Parameterized.Some

Methods

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

TraversableF (Const x :: (k -> Type) -> Type)

Defined in Data.Parameterized.TraversableF

Methods

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

TraversableF (MapF ktp :: (k -> Type) -> Type)

Defined in Data.Parameterized.Map

Methods

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

(TraversableF s, TraversableFC t) => TraversableF (Compose s t :: (l -> Type) -> Type)

Traverse twice over: go under the t, under the s and lift m out.

Defined in Data.Parameterized.TraversableF

Methods

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

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

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

forF_ :: (FoldableF t, Applicative m) => t f -> (forall x. f x -> m a) -> m ()

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

forF :: (TraversableF t, Applicative m) => t e -> (forall s. e s -> m (f s)) -> m (t f)

Flipped traverseF

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 the predicate.

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

Return True if any values satisfy the predicate.

lengthF :: FoldableF t => t f -> Int

Return number of elements that we fold over.