Module DA.Foldable

Class of data structures that can be folded to a summary value. It’s a good idea to import this module qualified to avoid clashes with functions defined in Prelude. Ie.:

import DA.Foldable qualified as F

Typeclasses

class Foldable t where

Class of data structures that can be folded to a summary value.

fold

: Monoid m => t m -> m

Combine the elements of a structure using a monoid.

foldMap

: Monoid m => (a -> m) -> t a -> m

Combine the elements of a structure using a monoid.

foldr

: (a -> b -> b) -> b -> t a -> b

Right-associative fold of a structure.

foldl

: (b -> a -> b) -> b -> t a -> b

Left-associative fold of a structure.

foldr1

: (a -> a -> a) -> t a -> a

A variant of foldr that has no base case, and thus should only be applied to non-empty structures.

foldl1

: (a -> a -> a) -> t a -> a

A variant of foldl that has no base case, and thus should only be applied to non-empty structures.

toList

: t a -> [a]

List of elements of a structure, from left to right.

null

: t a -> Bool

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

length

: t a -> Int

Returns the size/length of a finite structure as an Int. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

elem

: Eq a => a -> t a -> Bool

Does the element occur in the structure?

sum

: Additive a => t a -> a

The sum function computes the sum of the numbers of a structure.

product

: Multiplicative a => t a -> a

The product function computes the product of the numbers of a structure.

minimum

: Ord a => t a -> a

The least element of a non-empty structure.

maximum

: Ord a => t a -> a

The largest element of a non-empty structure.

instance Ord k => Foldable (Map k)

instance Foldable TextMap

instance Foldable Optional

instance Foldable (Map k)

instance Foldable NonEmpty

instance Foldable Set

instance Foldable (Either a)

instance Foldable ([])

instance Foldable a

Functions

mapA_

: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()

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 ‘DA.Traversable.mapA’.

forA_

: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()

‘for_’ is ‘mapA_’ with its arguments flipped. For a version that doesn’t ignore the results see ‘DA.Traversable.forA’.

sequence_

: (Foldable t, Action m) => t (m a) -> m ()

Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn’t ignore the results see ‘DA.Traversable.sequence’.

concat

: Foldable t => t [a] -> [a]

The concatenation of all the elements of a container of lists.

and

: Foldable t => t Bool -> Bool

and returns the conjunction of a container of Bools. For the result to be True, the container must be finite; False, however, results from a False value finitely far from the left end.

or

: Foldable t => t Bool -> Bool

or returns the disjunction of a container of Bools. For the result to be False, the container must be finite; True, however, results from a True value finitely far from the left end.

any

: Foldable t => (a -> Bool) -> t a -> Bool

Determines whether any element of the structure satisfies the predicate.

all

: Foldable t => (a -> Bool) -> t a -> Bool

Determines whether all elements of the structure satisfy the predicate.