Data.Foldable
- Package
- purescript-foldable-traversable
- Repository
- purescript/purescript-foldable-traversable
#Foldable Source
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)
#foldrDefault Source
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 Source
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
.
#foldMapDefaultL Source
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
.
#foldMapDefaultR Source
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
.
#traverse_ Source
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]
#for_ Source
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)
#sequence_ Source
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!" ]
#intercalate Source
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]
#surroundMap Source
surroundMap :: forall f a m. Foldable f => Semigroup m => m -> (a -> m) -> f a -> m
foldMap
but with each element surrounded by some fixed value.
For example:
> surroundMap "*" show []
= "*"
> surroundMap "*" show [1]
= "*1*"
> surroundMap "*" show [1, 2]
= "*1*2*"
> surroundMap "*" show [1, 2, 3]
= "*1*2*3*"
#and Source
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
.
#or Source
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
.
#all Source
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.
#any Source
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.