Safe Haskell	Safe

Eta.Classes.Traversable

Description

The Traversable type class defines that a structure can be traversed from left to right, applying some flatmappable function to it.

>> traverse readFile ["foo.txt", "bar.txt", "quux.txt"]
["foo contents" , "bar contents", "quux contents"]

It basically applies the actions inside of the type that the passed returns, and collects them, unless it fails.

safeDivide a b =
    if b == 0
    then Nothing
    else Just (a / b)

>>> traverse (safeDivide 2) [1, 2]
Just [2,1]

>>> traverse (safeDivide 2) [0, 2]
Nothing

Synopsis

Documentation

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

Minimal complete definition

traverse | sequenceA

Methods

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

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

Instances

Traversable []
Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] # sequenceA :: Applicative f => [f a] -> f [a] # mapM :: Monad m => (a -> m b) -> [a] -> m [b] sequence :: Monad m => [m a] -> m [a]
Traversable Maybe
Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) sequence :: Monad m => Maybe (m a) -> m (Maybe a)
Traversable V1
Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) # sequenceA :: Applicative f => V1 (f a) -> f (V1 a) # mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) sequence :: Monad m => V1 (m a) -> m (V1 a)
Traversable U1
Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) # sequenceA :: Applicative f => U1 (f a) -> f (U1 a) # mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) sequence :: Monad m => U1 (m a) -> m (U1 a)
Traversable Par1
Methods traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) # sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) # mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) sequence :: Monad m => Par1 (m a) -> m (Par1 a)
Traversable Sum
Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) sequence :: Monad m => Sum (m a) -> m (Sum a)
Traversable Product
Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) # sequenceA :: Applicative f => Product (f a) -> f (Product a) # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) sequence :: Monad m => Product (m a) -> m (Product a)
Traversable Last
Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) sequence :: Monad m => Last (m a) -> m (Last a)
Traversable First
Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) sequence :: Monad m => First (m a) -> m (First a)
Traversable Dual
Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) sequence :: Monad m => Dual (m a) -> m (Dual a)
Traversable ZipList
Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) sequence :: Monad m => ZipList (m a) -> m (ZipList a)
Traversable (Either a)
Methods traverse :: Applicative f => (a -> f b) -> Either a a -> f (Either a b) # sequenceA :: Applicative f => Either a (f a) -> f (Either a a) # mapM :: Monad m => (a -> m b) -> Either a a -> m (Either a b) sequence :: Monad m => Either a (m a) -> m (Either a a)
Traversable f => Traversable (Rec1 f)
Methods traverse :: Applicative f => (a -> f b) -> Rec1 f a -> f (Rec1 f b) # sequenceA :: Applicative f => Rec1 f (f a) -> f (Rec1 f a) # mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a)
Traversable (URec Char)
Methods traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) # sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) # mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) sequence :: Monad m => URec Char (m a) -> m (URec Char a)
Traversable (URec Double)
Methods traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) # sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) # mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) sequence :: Monad m => URec Double (m a) -> m (URec Double a)
Traversable (URec Float)
Methods traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) # sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) # mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) sequence :: Monad m => URec Float (m a) -> m (URec Float a)
Traversable (URec Int)
Methods traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) # sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) # mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) sequence :: Monad m => URec Int (m a) -> m (URec Int a)
Traversable (URec Word)
Methods traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) # sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) # mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) sequence :: Monad m => URec Word (m a) -> m (URec Word a)
Traversable (URec (Ptr ()))
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 ((,) a)
Methods traverse :: Applicative f => (a -> f b) -> (a, a) -> f (a, b) # sequenceA :: Applicative f => (a, f a) -> f (a, a) # mapM :: Monad m => (a -> m b) -> (a, a) -> m (a, b) sequence :: Monad m => (a, m a) -> m (a, a)
Ix i => Traversable (Array i)
Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) # sequenceA :: Applicative f => Array i (f a) -> f (Array i a) # mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) sequence :: Monad m => Array i (m a) -> m (Array i a)
Traversable (Proxy *)
Methods traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) # sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) # mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) sequence :: Monad m => Proxy * (m a) -> m (Proxy * a)
Traversable (K1 i c)
Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) # sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) # mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) sequence :: Monad m => K1 i c (m a) -> m (K1 i c a)
(Traversable f, Traversable g) => Traversable ((:+:) f g)
Methods traverse :: Applicative f => (a -> f b) -> (f :+: g) a -> f ((f :+: g) b) # sequenceA :: Applicative f => (f :+: g) (f a) -> f ((f :+: g) a) # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a)
(Traversable f, Traversable g) => Traversable ((:*:) f g)
Methods traverse :: Applicative f => (a -> f b) -> (f :: g) a -> f ((f :: g) b) # sequenceA :: Applicative f => (f :: g) (f a) -> f ((f :: g) a) # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a)
(Traversable f, Traversable g) => Traversable ((:.:) f g)
Methods traverse :: Applicative f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b) # sequenceA :: Applicative f => (f :.: g) (f a) -> f ((f :.: g) a) # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a)
Traversable (Const * m)
Methods traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b) # sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a) # mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b) sequence :: Monad m => Const * m (m a) -> m (Const * m a)
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) # sequenceA :: Applicative f => M1 i c f (f a) -> f (M1 i c f a) # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a)

for :: (Traversable t, Applicative m) => t a -> (a -> m b) -> m (t b) #

traverse with the arguments flipped, allows to work in an imperative manner, like with foreach:

>>> :{
 for [1..3] $ \i -> do
    let x = i + 1
    Just x
:}
Just [2,3,4]

sequence :: (Traversable t, Applicative m) => t (m a) -> m (t a) #

sequence moves the context of each of the elements of a Traversable structure to the structure itself

>>> sequence [Just 1, Just 2]
Just [1,2]

>>> sequence [Just 1, Nothing]
Nothing