Module

Data.FoldableWithIndex

Package
purescript-foldable-traversable
Repository
purescript/purescript-foldable-traversable

#FoldableWithIndex Source

class (Foldable f) <= FoldableWithIndex i f | f -> i where

A Foldable with an additional index. A FoldableWithIndex instance must be compatible with its Foldable instance

foldr f = foldrWithIndex (const f)
foldl f = foldlWithIndex (const f)
foldMap f = foldMapWithIndex (const f)

Default implementations are provided by the following functions:

  • foldrWithIndexDefault
  • foldlWithIndexDefault
  • foldMapWithIndexDefaultR
  • foldMapWithIndexDefaultL

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

Instances

#foldrWithIndexDefault Source

foldrWithIndexDefault :: forall i f a b. FoldableWithIndex i f => (i -> a -> b -> b) -> b -> f a -> b

A default implementation of foldrWithIndex using foldMapWithIndex.

Note: when defining a FoldableWithIndex instance, this function is unsafe to use in combination with foldMapWithIndexDefaultR.

#foldlWithIndexDefault Source

foldlWithIndexDefault :: forall i f a b. FoldableWithIndex i f => (i -> b -> a -> b) -> b -> f a -> b

A default implementation of foldlWithIndex using foldMapWithIndex.

Note: when defining a FoldableWithIndex instance, this function is unsafe to use in combination with foldMapWithIndexDefaultL.

#foldMapWithIndexDefaultR Source

foldMapWithIndexDefaultR :: forall i f a m. FoldableWithIndex i f => Monoid m => (i -> a -> m) -> f a -> m

A default implementation of foldMapWithIndex using foldrWithIndex.

Note: when defining a FoldableWithIndex instance, this function is unsafe to use in combination with foldrWithIndexDefault.

#foldMapWithIndexDefaultL Source

foldMapWithIndexDefaultL :: forall i f a m. FoldableWithIndex i f => Monoid m => (i -> a -> m) -> f a -> m

A default implementation of foldMapWithIndex using foldlWithIndex.

Note: when defining a FoldableWithIndex instance, this function is unsafe to use in combination with foldlWithIndexDefault.

#foldWithIndexM Source

foldWithIndexM :: forall i f m a b. FoldableWithIndex i f => Monad m => (i -> a -> b -> m a) -> a -> f b -> m a

Similar to 'foldlWithIndex', but the result is encapsulated in a monad.

Note: this function is not generally stack-safe, e.g., for monads which build up thunks a la Eff.

#traverseWithIndex_ Source

traverseWithIndex_ :: forall i a b f m. Applicative m => FoldableWithIndex i f => (i -> a -> m b) -> f a -> m Unit

Traverse a data structure with access to the index, performing some effects encoded by an Applicative functor at each value, ignoring the final result.

For example:

> traverseWithIndex_ (curry logShow) ["a", "b", "c"]
(Tuple 0 "a")
(Tuple 1 "b")
(Tuple 2 "c")

#forWithIndex_ Source

forWithIndex_ :: forall i a b f m. Applicative m => FoldableWithIndex i f => f a -> (i -> a -> m b) -> m Unit

A version of traverseWithIndex_ 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:

forWithIndex_ ["a", "b", "c"] \i x -> do
  logShow i
  log x

#surroundMapWithIndex Source

surroundMapWithIndex :: forall i f a m. FoldableWithIndex i f => Semigroup m => m -> (i -> a -> m) -> f a -> m

foldMapWithIndex but with each element surrounded by some fixed value.

For example:

> surroundMapWithIndex "*" (\i x -> show i <> x) []
= "*"

> surroundMapWithIndex "*" (\i x -> show i <> x) ["a"]
= "*0a*"

> surroundMapWithIndex "*" (\i x -> show i <> x) ["a", "b"]
= "*0a*1b*"

> surroundMapWithIndex "*" (\i x -> show i <> x) ["a", "b", "c"]
= "*0a*1b*2c*"

#allWithIndex Source

allWithIndex :: forall i a b f. FoldableWithIndex i f => HeytingAlgebra b => (i -> a -> b) -> f a -> b

allWithIndex f is the same as and <<< mapWithIndex f; map a function over the structure, and then get the conjunction of the results.

#anyWithIndex Source

anyWithIndex :: forall i a b f. FoldableWithIndex i f => HeytingAlgebra b => (i -> a -> b) -> f a -> b

anyWithIndex f is the same as or <<< mapWithIndex f; map a function over the structure, and then get the disjunction of the results.

#findWithIndex Source

findWithIndex :: forall i a f. FoldableWithIndex i f => (i -> a -> Boolean) -> f a -> Maybe { index :: i, value :: a }

Try to find an element in a data structure which satisfies a predicate with access to the index.

#foldrDefault Source

foldrDefault :: forall i f a b. FoldableWithIndex i f => (a -> b -> b) -> b -> f a -> b

A default implementation of foldr using foldrWithIndex

#foldlDefault Source

foldlDefault :: forall i f a b. FoldableWithIndex i f => (b -> a -> b) -> b -> f a -> b

A default implementation of foldl using foldlWithIndex

#foldMapDefault Source

foldMapDefault :: forall i f a m. FoldableWithIndex i f => Monoid m => (a -> m) -> f a -> m

A default implementation of foldMap using foldMapWithIndex