Data.Traversable
#Traversable
class Traversable :: (Type -> Type) -> Constraint
class (Functor t, Foldable t) <= Traversable t where
Traversable
represents data structures which can be traversed,
accumulating results and effects in some Applicative
functor.
traverse
runs an action for every element in a data structure, and accumulates the results.sequence
runs the actions contained in a data structure, and accumulates the results.
import Data.Traversable
import Data.Maybe
import Data.Int (fromNumber)
sequence [Just 1, Just 2, Just 3] == Just [1,2,3]
sequence [Nothing, Just 2, Just 3] == Nothing
traverse fromNumber [1.0, 2.0, 3.0] == Just [1,2,3]
traverse fromNumber [1.5, 2.0, 3.0] == Nothing
traverse logShow [1,2,3]
-- prints:
1
2
3
traverse (\x -> [x, 0]) [1,2,3] == [[1,2,3],[1,2,0],[1,0,3],[1,0,0],[0,2,3],[0,2,0],[0,0,3],[0,0,0]]
The traverse
and sequence
functions should be compatible in the
following sense:
traverse f xs = sequence (f <$> xs)
sequence = traverse identity
Traversable
instances should also be compatible with the corresponding
Foldable
instances, in the following sense:
foldMap f = runConst <<< traverse (Const <<< f)
Default implementations are provided by the following functions:
traverseDefault
sequenceDefault
Members
traverse :: forall a b m. Applicative m => (a -> m b) -> t a -> m (t b)
sequence :: forall a m. Applicative m => t (m a) -> m (t a)
Instances
Traversable Array
Traversable Maybe
Traversable First
Traversable Last
Traversable Additive
Traversable Dual
Traversable Conj
Traversable Disj
Traversable Multiplicative
Traversable (Either a)
Traversable (Tuple a)
Traversable Identity
Traversable (Const a)
(Traversable f, Traversable g) => Traversable (Product f g)
(Traversable f, Traversable g) => Traversable (Coproduct f g)
(Traversable f, Traversable g) => Traversable (Compose f g)
(Traversable f) => Traversable (App f)
#traverseDefault
traverseDefault :: forall t a b m. Traversable t => Applicative m => (a -> m b) -> t a -> m (t b)
A default implementation of traverse
using sequence
and map
.
#sequenceDefault
sequenceDefault :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)
A default implementation of sequence
using traverse
.
#for
for :: forall a b m t. Applicative m => Traversable t => t a -> (a -> m b) -> m (t b)
A version of traverse
with its arguments flipped.
This can be useful when running an action written using do notation for every element in a data structure:
For example:
for [1, 2, 3] \n -> do
print n
return (n * n)
#scanl
scanl :: forall a b f. Traversable f => (b -> a -> b) -> b -> f a -> f b
Fold a data structure from the left, keeping all intermediate results
instead of only the final result. Note that the initial value does not
appear in the result (unlike Haskell's Prelude.scanl
).
scanl (+) 0 [1,2,3] = [1,3,6]
scanl (-) 10 [1,2,3] = [9,7,4]
#scanr
scanr :: forall a b f. Traversable f => (a -> b -> b) -> b -> f a -> f b
Fold a data structure from the right, keeping all intermediate results
instead of only the final result. Note that the initial value does not
appear in the result (unlike Haskell's Prelude.scanr
).
scanr (+) 0 [1,2,3] = [6,5,3]
scanr (flip (-)) 10 [1,2,3] = [4,5,7]
#mapAccumL
mapAccumL :: forall a b s f. Traversable f => (s -> a -> Accum s b) -> s -> f a -> Accum s (f b)
Fold a data structure from the left, keeping all intermediate results instead of only the final result.
Unlike scanl
, mapAccumL
allows the type of accumulator to differ
from the element type of the final data structure.
#mapAccumR
mapAccumR :: forall a b s f. Traversable f => (s -> a -> Accum s b) -> s -> f a -> Accum s (f b)
Fold a data structure from the right, keeping all intermediate results instead of only the final result.
Unlike scanr
, mapAccumR
allows the type of accumulator to differ
from the element type of the final data structure.
Re-exports from Data.Foldable
#Foldable
class Foldable :: (Type -> Type) -> Constraint
class Foldable f where
Foldable
represents data structures which can be folded.
foldr
folds a structure from the rightfoldl
folds a structure from the leftfoldMap
folds a structure by accumulating values in aMonoid
Default implementations are provided by the following functions:
foldrDefault
foldlDefault
foldMapDefaultR
foldMapDefaultL
Note: some combinations of the default implementations are unsafe to use together - causing a non-terminating mutually recursive cycle. These combinations are documented per function.
Members
foldr :: forall a b. (a -> b -> b) -> b -> f a -> b
foldl :: forall a b. (b -> a -> b) -> b -> f a -> b
foldMap :: forall a m. Monoid m => (a -> m) -> f a -> m
Instances
Foldable Array
Foldable Maybe
Foldable First
Foldable Last
Foldable Additive
Foldable Dual
Foldable Disj
Foldable Conj
Foldable Multiplicative
Foldable (Either a)
Foldable (Tuple a)
Foldable Identity
Foldable (Const a)
(Foldable f, Foldable g) => Foldable (Product f g)
(Foldable f, Foldable g) => Foldable (Coproduct f g)
(Foldable f, Foldable g) => Foldable (Compose f g)
(Foldable f) => Foldable (App f)
#traverse_
traverse_ :: forall a b f m. Applicative m => Foldable f => (a -> m b) -> f a -> m Unit
Traverse a data structure, performing some effects encoded by an
Applicative
functor at each value, ignoring the final result.
For example:
traverse_ print [1, 2, 3]
#sum
#sequence_
sequence_ :: forall a f m. Applicative m => Foldable f => f (m a) -> m Unit
Perform all of the effects in some data structure in the order
given by the Foldable
instance, ignoring the final result.
For example:
sequence_ [ trace "Hello, ", trace " world!" ]
#or
or :: forall a f. Foldable f => HeytingAlgebra a => f a -> a
The disjunction of all the values in a data structure. When specialized
to Boolean
, this function will test whether any of the values in a data
structure is true
.
#oneOf
#notElem
#minimumBy
#minimum
#maximumBy
#maximum
#intercalate
intercalate :: forall f m. Foldable f => Monoid m => m -> f m -> m
Fold a data structure, accumulating values in some Monoid
,
combining adjacent elements using the specified separator.
For example:
> intercalate ", " ["Lorem", "ipsum", "dolor"]
= "Lorem, ipsum, dolor"
> intercalate "*" ["a", "b", "c"]
= "a*b*c"
> intercalate [1] [[2, 3], [4, 5], [6, 7]]
= [2, 3, 1, 4, 5, 1, 6, 7]
#for_
for_ :: forall a b f m. Applicative m => Foldable f => f a -> (a -> m b) -> m Unit
A version of traverse_
with its arguments flipped.
This can be useful when running an action written using do notation for every element in a data structure:
For example:
for_ [1, 2, 3] \n -> do
print n
trace "squared is"
print (n * n)
#foldrDefault
foldrDefault :: forall f a b. Foldable f => (a -> b -> b) -> b -> f a -> b
A default implementation of foldr
using foldMap
.
Note: when defining a Foldable
instance, this function is unsafe to use
in combination with foldMapDefaultR
.
#foldlDefault
foldlDefault :: forall f a b. Foldable f => (b -> a -> b) -> b -> f a -> b
A default implementation of foldl
using foldMap
.
Note: when defining a Foldable
instance, this function is unsafe to use
in combination with foldMapDefaultL
.
#foldMapDefaultR
foldMapDefaultR :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m
A default implementation of foldMap
using foldr
.
Note: when defining a Foldable
instance, this function is unsafe to use
in combination with foldrDefault
.
#foldMapDefaultL
foldMapDefaultL :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m
A default implementation of foldMap
using foldl
.
Note: when defining a Foldable
instance, this function is unsafe to use
in combination with foldlDefault
.
#fold
#find
#elem
#any
any :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b
any f
is the same as or <<< map f
; map a function over the structure,
and then get the disjunction of the results.
#and
and :: forall a f. Foldable f => HeytingAlgebra a => f a -> a
The conjunction of all the values in a data structure. When specialized
to Boolean
, this function will test whether all of the values in a data
structure are true
.
#all
all :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b
all f
is the same as and <<< map f
; map a function over the structure,
and then get the conjunction of the results.
Re-exports from Data.Traversable.Accum
Packages
assert
catenable-lists
const
convertable-options
datetime-parsing
debug
distributive
erl-atom
erl-gun
erl-lager
erl-logger
erl-maps
erl-modules
erl-nativerefs
erl-opentelemetry
- OpenTelemetry.Metrics
- OpenTelemetry.Metrics.Counter
- OpenTelemetry.Metrics.Meter
- OpenTelemetry.Metrics.SumObserver
- OpenTelemetry.Metrics.UpDownCounter
- OpenTelemetry.Metrics.UpDownSumObserver
- OpenTelemetry.Metrics.ValueObserver
- OpenTelemetry.Metrics.ValueRecorder
- OpenTelemetry.Tracing
- OpenTelemetry.Tracing.Baggage
- OpenTelemetry.Tracing.Ctx
- OpenTelemetry.Tracing.Propagator.TextMap
- OpenTelemetry.Tracing.Span
- OpenTelemetry.Tracing.Tracer
- Tracing.Attributes
erl-process
erl-queue
erl-ranch
erl-simplebus
erl-ssl
erl-test-eunit
erl-test-eunit-discovery
erl-tuples
erl-untagged-union
exceptions
exists
expect-inferred
functions
graphs
heterogeneous
identity
integers
invariant
js-uri
lazy
lcg
math
media-types
newtype
nonempty
nullable
ordered-collections
partial
prelude
- Control.Applicative
- Control.Apply
- Control.Bind
- Control.Category
- Control.Monad
- Control.Semigroupoid
- Data.Boolean
- Data.BooleanAlgebra
- Data.Bounded
- Data.Bounded.Generic
- Data.CommutativeRing
- Data.DivisionRing
- Data.Eq
- Data.Eq.Generic
- Data.EuclideanRing
- Data.Field
- Data.Function
- Data.Functor
- Data.Generic.Rep
- Data.HeytingAlgebra
- Data.HeytingAlgebra.Generic
- Data.Monoid
- Data.Monoid.Additive
- Data.Monoid.Conj
- Data.Monoid.Disj
- Data.Monoid.Dual
- Data.Monoid.Endo
- Data.Monoid.Generic
- Data.Monoid.Multiplicative
- Data.NaturalTransformation
- Data.Ord
- Data.Ord.Generic
- Data.Ordering
- Data.Ring
- Data.Ring.Generic
- Data.Semigroup
- Data.Semigroup.First
- Data.Semigroup.Generic
- Data.Semigroup.Last
- Data.Semiring
- Data.Semiring.Generic
- Data.Show
- Data.Show.Generic
- Data.Symbol
- Data.Unit
- Data.Void
- Record.Unsafe
- Type.Data.Row
- Type.Data.RowList
- Type.Proxy
profunctor-lenses
- Data.Lens.AffineTraversal
- Data.Lens.At
- Data.Lens.Common
- Data.Lens.Fold
- Data.Lens.Fold.Partial
- Data.Lens.Getter
- Data.Lens.Grate
- Data.Lens.Index
- Data.Lens.Indexed
- Data.Lens.Internal.Bazaar
- Data.Lens.Internal.Exchange
- Data.Lens.Internal.Focusing
- Data.Lens.Internal.Forget
- Data.Lens.Internal.Grating
- Data.Lens.Internal.Indexed
- Data.Lens.Internal.Market
- Data.Lens.Internal.Re
- Data.Lens.Internal.Shop
- Data.Lens.Internal.Stall
- Data.Lens.Internal.Tagged
- Data.Lens.Internal.Wander
- Data.Lens.Internal.Zipping
- Data.Lens.Iso
- Data.Lens.Iso.Newtype
- Data.Lens.Lens
- Data.Lens.Lens.Product
- Data.Lens.Lens.Tuple
- Data.Lens.Lens.Unit
- Data.Lens.Lens.Void
- Data.Lens.Prism
- Data.Lens.Prism.Coproduct
- Data.Lens.Prism.Either
- Data.Lens.Prism.Maybe
- Data.Lens.Record
- Data.Lens.Setter
- Data.Lens.Traversal
- Data.Lens.Types
- Data.Lens.Zoom
psci-support
quickcheck-laws
- Test.QuickCheck.Laws
- Test.QuickCheck.Laws.Control.Alt
- Test.QuickCheck.Laws.Control.Alternative
- Test.QuickCheck.Laws.Control.Applicative
- Test.QuickCheck.Laws.Control.Apply
- Test.QuickCheck.Laws.Control.Bind
- Test.QuickCheck.Laws.Control.Category
- Test.QuickCheck.Laws.Control.Comonad
- Test.QuickCheck.Laws.Control.Extend
- Test.QuickCheck.Laws.Control.Monad
- Test.QuickCheck.Laws.Control.MonadPlus
- Test.QuickCheck.Laws.Control.MonadZero
- Test.QuickCheck.Laws.Control.Plus
- Test.QuickCheck.Laws.Control.Semigroupoid
- Test.QuickCheck.Laws.Data.BooleanAlgebra
- Test.QuickCheck.Laws.Data.Bounded
- Test.QuickCheck.Laws.Data.BoundedEnum
- Test.QuickCheck.Laws.Data.CommutativeRing
- Test.QuickCheck.Laws.Data.DivisionRing
- Test.QuickCheck.Laws.Data.Eq
- Test.QuickCheck.Laws.Data.EuclideanRing
- Test.QuickCheck.Laws.Data.Field
- Test.QuickCheck.Laws.Data.Foldable
- Test.QuickCheck.Laws.Data.Functor
- Test.QuickCheck.Laws.Data.FunctorWithIndex
- Test.QuickCheck.Laws.Data.HeytingAlgebra
- Test.QuickCheck.Laws.Data.Monoid
- Test.QuickCheck.Laws.Data.Ord
- Test.QuickCheck.Laws.Data.Ring
- Test.QuickCheck.Laws.Data.Semigroup
- Test.QuickCheck.Laws.Data.Semiring
random
rationals
record-prefix
refs
safe-coerce
semirings
simple-json
strings
- Data.Char
- Data.Char.Gen
- Data.String.CaseInsensitive
- Data.String.CodePoints
- Data.String.CodeUnits
- Data.String.Common
- Data.String.Gen
- Data.String.NonEmpty.CaseInsensitive
- Data.String.NonEmpty.CodePoints
- Data.String.NonEmpty.CodeUnits
- Data.String.NonEmpty.Internal
- Data.String.Pattern
- Data.String.Regex
- Data.String.Regex.Flags
- Data.String.Regex.Unsafe
- Data.String.Unsafe
tailrec
transformers
- Control.Comonad.Env
- Control.Comonad.Env.Class
- Control.Comonad.Env.Trans
- Control.Comonad.Store
- Control.Comonad.Store.Class
- Control.Comonad.Store.Trans
- Control.Comonad.Traced
- Control.Comonad.Traced.Class
- Control.Comonad.Traced.Trans
- Control.Comonad.Trans.Class
- Control.Monad.Cont
- Control.Monad.Cont.Class
- Control.Monad.Cont.Trans
- Control.Monad.Error.Class
- Control.Monad.Except
- Control.Monad.Except.Trans
- Control.Monad.Identity.Trans
- Control.Monad.List.Trans
- Control.Monad.Maybe.Trans
- Control.Monad.RWS
- Control.Monad.RWS.Trans
- Control.Monad.Reader
- Control.Monad.Reader.Class
- Control.Monad.Reader.Trans
- Control.Monad.State
- Control.Monad.State.Class
- Control.Monad.State.Trans
- Control.Monad.Trans.Class
- Control.Monad.Writer
- Control.Monad.Writer.Class
- Control.Monad.Writer.Trans
type-equality
undefinable
unfoldable
unsafe-coerce
unsafe-reference
uri
- URI.AbsoluteURI
- URI.Authority
- URI.Common
- URI.Extra.MultiHostPortPair
- URI.Extra.QueryPairs
- URI.Extra.UserPassInfo
- URI.Fragment
- URI.HierarchicalPart
- URI.Host
- URI.Host.Gen
- URI.Host.IPv4Address
- URI.Host.IPv6Address
- URI.Host.RegName
- URI.HostPortPair
- URI.HostPortPair.Gen
- URI.Path
- URI.Path.Absolute
- URI.Path.NoScheme
- URI.Path.Rootless
- URI.Path.Segment
- URI.Port
- URI.Port.Gen
- URI.Query
- URI.RelativePart
- URI.RelativeRef
- URI.Scheme
- URI.Scheme.Common
- URI.URI
- URI.URIRef
- URI.UserInfo