traverse_ -package:sop-core

Map each element of a structure to an Applicative action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see traverse. traverse_ is just like mapM_, but generalised to Applicative actions.

Examples

Basic usage:

>>> traverse_ print ["Hello", "world", "!"]
"Hello"
"world"
"!"

Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see traverse.

Synonym for otraverse_

Visit every node in the given list. If new nodes are appended during the traversal, they will not be visited. Every live node that was in the list when the traversal began will be visited exactly once; however, no guarantee is made about the order of the traversal.

Visit every node in the given list. If new nodes are appended during the traversal, they will not be visited. Every live node that was in the list when the traversal began will be visited exactly once; however, no guarantee is made about the order of the traversal.

Execute, traversing the stream with a side effect in the inner monad.

Map each element of the array to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see traverse.

Map each element of a collection to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see traverse

Map each element to an action, evaluate these actions from left to right and ignore the results. Note that the return type is Void instead of usual ().

>>> traverse_ print (0...) -- hit Ctrl+C to terminate
0
1
2Interrupted

traverse_ could be productive for some short-circuiting f:

>>> traverse_ (\x -> if x > 10 then Left x else Right ()) (0...)
Left 11

Efficiently mapReduce a Generator using the Traversal monoid. A specialized version of its namesake from Data.Foldable

mapReduce getTraversal

Despite the ridiculous-looking signature, this is in fact equivalent to traverse_ within Hask.

This is generally a faster way to traverse while ignoring the result rather than using mapM_.

Map each element of a structure using one of two actions, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see bitraverse.

Examples

Basic usage:

>>> bitraverse_ print (print . show) ("Hello", True)
"Hello"
"True"

>>> bitraverse_ print (print . show) (Right True)
"True"

>>> bitraverse_ print (print . show) (Left "Hello")
"Hello"

Traverse elements with access to the index i, discarding the results. When you don't need access to the index then traverse_ is more flexible in what it accepts.

traverse_ l = itraverse . const

Map each element of a structure using one of two actions, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see bitraverse.

A generalization of traverse_ or foldMap.

Corresponds to traverse_. Instances:

hctraverse_, ctraverse__NP  :: (All  c xs , Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> NP  f xs  -> g ()
hctraverse_, ctraverse__NS  :: (All2 c xs , Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> NS  f xs  -> g ()
hctraverse_, ctraverse__POP :: (All  c xss, Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> POP f xss -> g ()
hctraverse_, ctraverse__SOP :: (All2 c xss, Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> SOP f xss -> g ()