W3cubDocs

/Haskell 8

Data.Traversable

Copyright Conor McBride and Ross Paterson 2005
License BSD-style (see the LICENSE file in the distribution)
Maintainer [email protected]
Stability experimental
Portability portable
Safe Haskell Trustworthy
Language Haskell2010

Description

Class of data structures that can be traversed from left to right, performing an action on each element.

See also

The Traversable class

class (Functor t, Foldable t) => Traversable t where Source

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

A definition of traverse must satisfy the following laws:

naturality
t . traverse f = traverse (t . f) for every applicative transformation t
identity
traverse Identity = Identity
composition
traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality
t . sequenceA = sequenceA . fmap t for every applicative transformation t
identity
sequenceA . fmap Identity = Identity
composition
sequenceA . fmap Compose = Compose . fmap sequenceA . 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:

Minimal complete definition

traverse | sequenceA

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. For a version that ignores the results see traverse_.

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

Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_.

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. For a version that ignores the results see mapM_.

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. For a version that ignores the results see sequence_.

Instances

Traversable []

Since: 2.1

Methods

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

sequenceA :: Applicative f => [f a] -> f [a] Source

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

sequence :: Monad m => [m a] -> m [a] Source

Traversable Maybe

Since: 2.1

Methods

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

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

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

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

Traversable Par1

Methods

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

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

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

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

Traversable Last

Since: 4.8.0.0

Methods

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

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

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

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

Traversable First

Since: 4.8.0.0

Methods

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

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

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

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

Traversable Product

Since: 4.8.0.0

Methods

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

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

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

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

Traversable Sum

Since: 4.8.0.0

Methods

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

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

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

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

Traversable Dual

Since: 4.8.0.0

Methods

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

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

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

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

Traversable Identity

Methods

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

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

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

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

Traversable ZipList

Since: 4.9.0.0

Methods

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

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

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

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

Traversable NonEmpty

Since: 4.9.0.0

Methods

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

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

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

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

Traversable Option

Since: 4.9.0.0

Methods

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

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

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

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

Traversable Last

Since: 4.9.0.0

Methods

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

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

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

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

Traversable First

Since: 4.9.0.0

Methods

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

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

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

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

Traversable Max

Since: 4.9.0.0

Methods

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

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

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

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

Traversable Min

Since: 4.9.0.0

Methods

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

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

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

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

Traversable Complex

Methods

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

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

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

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

Traversable (Either a)

Since: 4.7.0.0

Methods

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

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

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

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

Traversable (V1 *)

Methods

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

sequenceA :: Applicative f => V1 * (f a) -> f (V1 * a) Source

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

sequence :: Monad m => V1 * (m a) -> m (V1 * a) Source

Traversable (U1 *)

Since: 4.9.0.0

Methods

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

sequenceA :: Applicative f => U1 * (f a) -> f (U1 * a) Source

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

sequence :: Monad m => U1 * (m a) -> m (U1 * a) Source

Traversable ((,) a)

Since: 4.7.0.0

Methods

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

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

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

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

Traversable (Proxy *)

Since: 4.7.0.0

Methods

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

sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) Source

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

sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) Source

Traversable (Arg a)

Since: 4.9.0.0

Methods

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

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

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

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

Traversable f => Traversable (Rec1 * f)

Methods

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

sequenceA :: Applicative f => Rec1 * f (f a) -> f (Rec1 * f a) Source

mapM :: Monad m => (a -> m b) -> Rec1 * f a -> m (Rec1 * f b) Source

sequence :: Monad m => Rec1 * f (m a) -> m (Rec1 * f a) Source

Traversable (URec * Char)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Char a -> f (URec * Char b) Source

sequenceA :: Applicative f => URec * Char (f a) -> f (URec * Char a) Source

mapM :: Monad m => (a -> m b) -> URec * Char a -> m (URec * Char b) Source

sequence :: Monad m => URec * Char (m a) -> m (URec * Char a) Source

Traversable (URec * Double)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Double a -> f (URec * Double b) Source

sequenceA :: Applicative f => URec * Double (f a) -> f (URec * Double a) Source

mapM :: Monad m => (a -> m b) -> URec * Double a -> m (URec * Double b) Source

sequence :: Monad m => URec * Double (m a) -> m (URec * Double a) Source

Traversable (URec * Float)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Float a -> f (URec * Float b) Source

sequenceA :: Applicative f => URec * Float (f a) -> f (URec * Float a) Source

mapM :: Monad m => (a -> m b) -> URec * Float a -> m (URec * Float b) Source

sequence :: Monad m => URec * Float (m a) -> m (URec * Float a) Source

Traversable (URec * Int)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Int a -> f (URec * Int b) Source

sequenceA :: Applicative f => URec * Int (f a) -> f (URec * Int a) Source

mapM :: Monad m => (a -> m b) -> URec * Int a -> m (URec * Int b) Source

sequence :: Monad m => URec * Int (m a) -> m (URec * Int a) Source

Traversable (URec * Word)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Word a -> f (URec * Word b) Source

sequenceA :: Applicative f => URec * Word (f a) -> f (URec * Word a) Source

mapM :: Monad m => (a -> m b) -> URec * Word a -> m (URec * Word b) Source

sequence :: Monad m => URec * Word (m a) -> m (URec * Word a) Source

Traversable (URec * (Ptr ()))

Methods

traverse :: Applicative f => (a -> f b) -> URec * (Ptr ()) a -> f (URec * (Ptr ()) b) Source

sequenceA :: Applicative f => URec * (Ptr ()) (f a) -> f (URec * (Ptr ()) a) Source

mapM :: Monad m => (a -> m b) -> URec * (Ptr ()) a -> m (URec * (Ptr ()) b) Source

sequence :: Monad m => URec * (Ptr ()) (m a) -> m (URec * (Ptr ()) a) Source

Traversable (Const * m)

Since: 4.7.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b) Source

sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a) Source

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

sequence :: Monad m => Const * m (m a) -> m (Const * m a) Source

Traversable (K1 * i c)

Methods

traverse :: Applicative f => (a -> f b) -> K1 * i c a -> f (K1 * i c b) Source

sequenceA :: Applicative f => K1 * i c (f a) -> f (K1 * i c a) Source

mapM :: Monad m => (a -> m b) -> K1 * i c a -> m (K1 * i c b) Source

sequence :: Monad m => K1 * i c (m a) -> m (K1 * i c a) Source

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

Methods

traverse :: Applicative f => (a -> f b) -> (* :+: f) g a -> f ((* :+: f) g b) Source

sequenceA :: Applicative f => (* :+: f) g (f a) -> f ((* :+: f) g a) Source

mapM :: Monad m => (a -> m b) -> (* :+: f) g a -> m ((* :+: f) g b) Source

sequence :: Monad m => (* :+: f) g (m a) -> m ((* :+: f) g a) Source

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

Methods

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

sequenceA :: Applicative f => (* :*: f) g (f a) -> f ((* :*: f) g a) Source

mapM :: Monad m => (a -> m b) -> (* :*: f) g a -> m ((* :*: f) g b) Source

sequence :: Monad m => (* :*: f) g (m a) -> m ((* :*: f) g a) Source

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

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Sum * f g a -> f (Sum * f g b) Source

sequenceA :: Applicative f => Sum * f g (f a) -> f (Sum * f g a) Source

mapM :: Monad m => (a -> m b) -> Sum * f g a -> m (Sum * f g b) Source

sequence :: Monad m => Sum * f g (m a) -> m (Sum * f g a) Source

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

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Product * f g a -> f (Product * f g b) Source

sequenceA :: Applicative f => Product * f g (f a) -> f (Product * f g a) Source

mapM :: Monad m => (a -> m b) -> Product * f g a -> m (Product * f g b) Source

sequence :: Monad m => Product * f g (m a) -> m (Product * f g a) Source

Traversable f => Traversable (M1 * i c f)

Methods

traverse :: Applicative f => (a -> f b) -> M1 * i c f a -> f (M1 * i c f b) Source

sequenceA :: Applicative f => M1 * i c f (f a) -> f (M1 * i c f a) Source

mapM :: Monad m => (a -> m b) -> M1 * i c f a -> m (M1 * i c f b) Source

sequence :: Monad m => M1 * i c f (m a) -> m (M1 * i c f a) Source

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

Methods

traverse :: Applicative f => (a -> f b) -> (* :.: *) f g a -> f ((* :.: *) f g b) Source

sequenceA :: Applicative f => (* :.: *) f g (f a) -> f ((* :.: *) f g a) Source

mapM :: Monad m => (a -> m b) -> (* :.: *) f g a -> m ((* :.: *) f g b) Source

sequence :: Monad m => (* :.: *) f g (m a) -> m ((* :.: *) f g a) Source

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

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b) Source

sequenceA :: Applicative f => Compose * * f g (f a) -> f (Compose * * f g a) Source

mapM :: Monad m => (a -> m b) -> Compose * * f g a -> m (Compose * * f g b) Source

sequence :: Monad m => Compose * * f g (m a) -> m (Compose * * f g a) Source

Utility functions

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

for is traverse with its arguments flipped. For a version that ignores the results see for_.

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) Source

forM is mapM with its arguments flipped. For a version that ignores the results see forM_.

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

The mapAccumL function behaves like a combination of fmap and 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 function behaves like a combination of 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.

General definitions for superclass methods

fmapDefault :: forall t a b. Traversable t => (a -> b) -> t a -> t b Source

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.)

fmapDefault f ≡ runIdentity . traverse (Identity . f)

foldMapDefault :: forall t m a. (Traversable t, Monoid m) => (a -> m) -> t a -> m Source

This function may be used as a value for foldMap in a Foldable instance.

foldMapDefault f ≡ getConst . traverse (Const . f)

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.2.1/docs/html/libraries/base-4.10.0.0/Data-Traversable.html