Data.Traversable (original) (raw)

Synopsis

• class (Functor t, Foldable t) => Traversable t where
  • traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
  • sequenceA :: Applicative f => t (f a) -> f (t a)
  • mapM :: Monad m => (a -> m b) -> t a -> m (t b)
  • sequence :: Monad m => t (m a) -> m (t a)
• for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
• forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
• mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
• mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
• fmapDefault :: Traversable t => (a -> b) -> t a -> t b
• foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m

Documentation

class (Functor t, Foldable t) => Traversable t whereSource

Functors representing data structures that can be traversed from left to right.

Minimal complete definition: [traverse](Data-Traversable.html#v:traverse) or [sequenceA](Data-Traversable.html#v:sequenceA).

Instances are similar to [Functor](Control-Monad.html#t: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 [<*>](Control-Applicative.html#v:-60--42--62-) imply a form of associativity.

The superclass instances should satisfy the following:

• In the [Functor](Control-Monad.html#t:Functor) instance, [fmap](Control-Monad.html#v:fmap) should be equivalent to traversal with the identity applicative functor ([fmapDefault](Data-Traversable.html#v:fmapDefault)).
• In the [Foldable](Data-Foldable.html#t:Foldable) instance, [foldMap](Data-Foldable.html#t:foldMap) should be equivalent to traversal with a constant applicative functor ([foldMapDefault](Data-Traversable.html#v:foldMapDefault)).

Methods

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

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

sequenceA :: Applicative f => t (f a) -> f (t a)Source

Evaluate each action in the structure from left to right, and collect the results.

mapM :: Monad m => (a -> m b) -> t a -> m (t b)Source

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

sequence :: Monad m => t (m a) -> m (t a)Source

Evaluate each monadic action in the structure from left to right, and collect the results.

mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)Source

The [mapAccumL](Data-Traversable.html#v:mapAccumL) function behaves like a combination of [fmap](Control-Monad.html#v:fmap) and [foldl](Data-List.html#v:foldl); it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.

mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)Source

The [mapAccumR](Data-Traversable.html#v:mapAccumR) function behaves like a combination of [fmap](Control-Monad.html#v:fmap) and foldr; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure.