
Data.Traversable  Portability  portable  Stability  experimental  Maintainer  ross@soi.city.ac.uk 



Description 
Class of data structures that can be traversed from left to right,
performing an action on each element.
See also
Note that the functions mapM and sequence generalize Prelude
functions of the same names from lists to any Traversable functor.
To avoid ambiguity, either import the Prelude hiding these names
or qualify uses of these function names with an alias for this module.


Synopsis 



Documentation 

class (Functor t, Foldable t) => Traversable t where 
Functors representing data structures that can be traversed from
left to right.
Minimal complete definition: traverse or sequenceA.
Instances are similar to 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
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 <*>
imply a form of associativity.
The superclass instances should satisfy the following:
  Methods  traverse :: Applicative f => (a > f b) > t a > f (t b)  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)  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)  Map each element of a structure to an monadic action, evaluate
these actions from left to right, and collect the results.
  sequence :: Monad m => t (m a) > m (t a)  Evaluate each monadic action in the structure from left to right,
and collect the results.

  Instances  


for :: (Traversable t, Applicative f) => t a > (a > f b) > f (t b) 
for is traverse with its arguments flipped.


forM :: (Traversable t, Monad m) => t a > (a > m b) > m (t b) 
forM is mapM with its arguments flipped.


fmapDefault :: Traversable t => (a > b) > t a > t b 
This function may be used as a value for fmap in a Functor instance.


foldMapDefault :: (Traversable t, Monoid m) => (a > m) > t a > m 
This function may be used as a value for foldMap
in a Foldable instance.


Produced by Haddock version 0.8 