Algebra.Traversable

Documentation

module Algebra.Applicative

module Algebra.Foldable

class Foldable t => Traversable t where

Methods

sequence :: Applicative f => t (f a) -> f (t a)

Instances

Traversable []

Traversable Maybe

Traversable Tree

Traversable Interleave

Traversable OrdList

Traversable ZipTree

Traversable ZipList

Traversable TimeVal

Traversable (Either a)

Traversable ((,) c)

Eq k => Traversable (Map k)

Traversable m => Traversable (MaybeT m)

Traversable m => Traversable (TreeT m)

Traversable m => Traversable (ListT m)

Traversable (Future t)

Traversable (Event t)

(Traversable f, Traversable g) => Traversable (:++: f g)

(Traversable f, Traversable g) => Traversable (:**: f g)

(Traversable f, Traversable g) => Traversable (:.: f g)

(Traversable f, Traversable g) => Traversable (Compose' f g)

Traversable m => Traversable (WriterT w m)

Traversable m => Traversable (EitherT e m)

Traversable m => Traversable (RWST Void w Void m)

class Functor t => Contravariant t where

Methods

collect :: Functor f => f (t a) -> t (f a)

Instances

Contravariant Id

Contravariant ((->) a)

traverse :: (Applicative f, Traversable t) => (a -> f b) -> t a -> f (t b)

foreach :: (Applicative f, Traversable t) => t a -> (a -> f b) -> f (t b)

transpose :: (Applicative f, Traversable t) => t (f a) -> f (t a)

flip :: (Contravariant c, Functor f) => f (c a) -> c (f a)

project :: (Contravariant c, Functor f) => (a -> c b) -> f a -> c (f b)

The Contravariant version of traverse

doTimes :: Applicative f => Int -> f a -> f [a]

converted :: (Unit f, Unit g, Foldable f, Foldable g, Monoid (f a), Monoid (g b)) => Iso (f a) (f b) (g a) (g b)

folded :: (Unit f', Foldable f, Monoid m) => Iso m m' (f m) (f' m')