| Copyright | Conor McBride and Ross Paterson 2005 |
|---|---|
| License | BSD-style (see the LICENSE file in the distribution) |
| Maintainer | libraries@haskell.org |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
Data.Traversable
Description
Class of data structures that can be traversed from left to right, performing an action on each element.
See also
- "Applicative Programming with Effects", by Conor McBride and Ross Paterson, Journal of Functional Programming 18:1 (2008) 1-13, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html.
- "The Essence of the Iterator Pattern", by Jeremy Gibbons and Bruno Oliveira, in Mathematically-Structured Functional Programming, 2006, online at http://web.comlab.ox.ac.uk/oucl/work/jeremy.gibbons/publications/#iterator.
- "An Investigation of the Laws of Traversals", by Mauro Jaskelioff and Ondrej Rypacek, in Mathematically-Structured Functional Programming, 2012, online at http://arxiv.org/pdf/1202.2919.
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 :: forall t a b. Traversable t => (a -> b) -> t a -> t b
- foldMapDefault :: forall t m a. (Traversable t, Monoid m) => (a -> m) -> t a -> m
The Traversable class
class (Functor t, Foldable t) => Traversable t where #
Functors representing data structures that can be traversed from left to right.
A definition of traverse must satisfy the following laws:
- naturality
t .for every applicative transformationtraversef =traverse(t . f)t- identity
traverseIdentity = Identity- composition
traverse(Compose .fmapg . f) = Compose .fmap(traverseg) .traversef
A definition of sequenceA must satisfy the following laws:
- naturality
t .for every applicative transformationsequenceA=sequenceA.fmaptt- identity
sequenceA.fmapIdentity = Identity- composition
sequenceA.fmapCompose = Compose .fmapsequenceA.sequenceA
where an applicative transformation is a function
t :: (Applicative f, Applicative g) => f a -> g a
preserving the Applicative operations, i.e.
and the identity functor Identity and composition of functors Compose
are defined as
newtype Identity a = Identity a
instance Functor Identity where
fmap f (Identity x) = Identity (f x)
instance Applicative Identity where
pure x = Identity x
Identity f <*> Identity x = Identity (f x)
newtype Compose f g a = Compose (f (g a))
instance (Functor f, Functor g) => Functor (Compose f g) where
fmap f (Compose x) = Compose (fmap (fmap f) x)
instance (Applicative f, Applicative g) => Applicative (Compose f g) where
pure x = Compose (pure (pure x))
Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)(The naturality law is implied by parametricity.)
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 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 <*>
imply a form of associativity.
The superclass instances should satisfy the following:
- In the
Functorinstance,fmapshould be equivalent to traversal with the identity applicative functor (fmapDefault). - In the
Foldableinstance,foldMapshould be equivalent to traversal with a constant applicative functor (foldMapDefault).
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. For a version that ignores
the results see traverse_.
sequenceA :: Applicative f => t (f a) -> f (t a) #
Evaluate each action in the structure from left to right, and
collect the results. For a version that ignores the results
see sequenceA_.
mapM :: Monad m => (a -> m b) -> t a -> m (t b) #
Map each element of a structure to a monadic action, evaluate
these actions from left to right, and collect the results. For
a version that ignores the results see mapM_.
sequence :: Monad m => t (m a) -> m (t a) #
Evaluate each monadic action in the structure from left to
right, and collect the results. For a version that ignores the
results see sequence_.
Instances
| Traversable [] # | Since: base-2.1 |
Defined in Data.Traversable | |
| Traversable Maybe # | Since: base-2.1 |
| Traversable Par1 # | Since: base-4.9.0.0 |
| Traversable NonEmpty # | Since: base-4.9.0.0 |
| Traversable Down # | Since: base-4.12.0.0 |
| Traversable Product # | Since: base-4.8.0.0 |
| Traversable Sum # | Since: base-4.8.0.0 |
| Traversable Dual # | Since: base-4.8.0.0 |
| Traversable Last # | Since: base-4.8.0.0 |
| Traversable First # | Since: base-4.8.0.0 |
| Traversable Identity # | Since: base-4.9.0.0 |
| Traversable ZipList # | Since: base-4.9.0.0 |
| Traversable Option # | Since: base-4.9.0.0 |
| Traversable Last # | Since: base-4.9.0.0 |
| Traversable First # | Since: base-4.9.0.0 |
| Traversable Max # | Since: base-4.9.0.0 |
| Traversable Min # | Since: base-4.9.0.0 |
| Traversable Complex # | Since: base-4.9.0.0 |
| Traversable (Either a) # | Since: base-4.7.0.0 |
Defined in Data.Traversable | |
| Traversable (V1 :: Type -> Type) # | Since: base-4.9.0.0 |
| Traversable (U1 :: Type -> Type) # | Since: base-4.9.0.0 |
| Traversable ((,) a) # | Since: base-4.7.0.0 |
Defined in Data.Traversable | |
| Traversable (Proxy :: Type -> Type) # | Since: base-4.7.0.0 |
| Traversable (Arg a) # | Since: base-4.9.0.0 |
| Traversable f => Traversable (Rec1 f) # | Since: base-4.9.0.0 |
| Traversable (URec Char :: Type -> Type) # | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| Traversable (URec Double :: Type -> Type) # | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| Traversable (URec Float :: Type -> Type) # | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| Traversable (URec Int :: Type -> Type) # | Since: base-4.9.0.0 |
| Traversable (URec Word :: Type -> Type) # | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| Traversable (URec (Ptr ()) :: Type -> Type) # | Since: base-4.9.0.0 |
Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b) # sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a) # mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b) # sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a) # | |
| Traversable f => Traversable (Alt f) # | Since: base-4.12.0.0 |
| Traversable f => Traversable (Ap f) # | Since: base-4.12.0.0 |
| Traversable (Const m :: Type -> Type) # | Since: base-4.7.0.0 |
| Traversable (K1 i c :: Type -> Type) # | Since: base-4.9.0.0 |
| (Traversable f, Traversable g) => Traversable (f :+: g) # | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| (Traversable f, Traversable g) => Traversable (f :*: g) # | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| (Traversable f, Traversable g) => Traversable (Sum f g) # | Since: base-4.9.0.0 |
| (Traversable f, Traversable g) => Traversable (Product f g) # | Since: base-4.9.0.0 |
Defined in Data.Functor.Product | |
| Traversable f => Traversable (M1 i c f) # | Since: base-4.9.0.0 |
| (Traversable f, Traversable g) => Traversable (f :.: g) # | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| (Traversable f, Traversable g) => Traversable (Compose f g) # | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose | |
Utility functions
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) #
General definitions for superclass methods
fmapDefault :: forall t a b. Traversable t => (a -> b) -> t a -> t b #
This function may be used as a value for fmap in a Functor
instance, provided that traverse is defined. (Using
fmapDefault with a Traversable instance defined only by
sequenceA will result in infinite recursion.)
fmapDefaultf ≡runIdentity.traverse(Identity. f)
foldMapDefault :: forall t m a. (Traversable t, Monoid m) => (a -> m) -> t a -> m #