Bifoldable

Bifoldable

class Bifoldable (p :: * -> * -> *) where

Bifoldable identifies foldable structures with two different varieties of elements (as opposed to Foldable, which has one variety of element). Common examples are Either and '(,)':

instance Bifoldable Either where
  bifoldMap f _ (Left  a) = f a
  bifoldMap _ g (Right b) = g b

instance Bifoldable (,) where
  bifoldr f g z (a, b) = f a (g b z)

A minimal Bifoldable definition consists of either bifoldMap or bifoldr. When defining more than this minimal set, one should ensure that the following identities hold:

bifold ≡ bifoldMap id id
bifoldMap f g ≡ bifoldr (mappend . f) (mappend . g) mempty
bifoldr f g z t ≡ appEndo (bifoldMap (Endo . f) (Endo . g) t) z

If the type is also a Bifunctor instance, it should satisfy:

'bifoldMap' f g ≡ 'bifold' . 'bimap' f g

which implies that

'bifoldMap' f g . 'bimap' h i ≡ 'bifoldMap' (f . h) (g . i)

Since: base-4.10.0.0

Minimal complete definition

bifoldr | bifoldMap

Methods

bifold :: Monoid m => p m m -> m

Combines the elements of a structure using a monoid.

bifold ≡ bifoldMap id id

Since: base-4.10.0.0

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> p a b -> m

Combines the elements of a structure, given ways of mapping them to a common monoid.

bifoldMap f g
     ≡ bifoldr (mappend . f) (mappend . g) mempty

Since: base-4.10.0.0

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c

Combines the elements of a structure in a right associative manner. Given a hypothetical function toEitherList :: p a b -> [Either a b] yielding a list of all elements of a structure in order, the following would hold:

bifoldr f g z ≡ foldr (either f g) z . toEitherList

Since: base-4.10.0.0

Instances

Bifoldable Either

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => Either m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Either a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Either a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Either a b -> c

Bifoldable (,)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (m, m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (a, b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (a, b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (a, b) -> c

Bifoldable Arg

Since: base-4.10.0.0

Defined in Data.Semigroup

Methods

bifold :: Monoid m => Arg m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Arg a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Arg a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Arg a b -> c

Bifoldable ((,,) x)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, m, m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, a, b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, a, b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, a, b) -> c

Bifoldable (Const :: * -> * -> *)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => Const m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c

Foldable f => Bifoldable (FreeF f)

Defined in Control.Monad.Trans.Free

Methods

bifold :: Monoid m => FreeF f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> FreeF f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> FreeF f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> FreeF f a b -> c

Foldable f => Bifoldable (CofreeF f)

Defined in Control.Comonad.Trans.Cofree

Methods

bifold :: Monoid m => CofreeF f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> CofreeF f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> CofreeF f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> CofreeF f a b -> c

Bifoldable (Tagged :: * -> * -> *)

Defined in Data.Tagged

Methods

bifold :: Monoid m => Tagged m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Tagged a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Tagged a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Tagged a b -> c

Bifoldable (K1 i :: * -> * -> *)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => K1 i m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> K1 i a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> K1 i a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> K1 i a b -> c

Bifoldable ((,,,) x y)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, y, m, m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, a, b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, a, b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, a, b) -> c

Bifoldable ((,,,,) x y z)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, y, z, m, m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, z, a, b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, z, a, b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, z, a, b) -> c

Bifoldable p => Bifoldable (WrappedBifunctor p)

Defined in Data.Bifunctor.Wrapped

Methods

bifold :: Monoid m => WrappedBifunctor p m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> WrappedBifunctor p a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> WrappedBifunctor p a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> WrappedBifunctor p a b -> c

Foldable g => Bifoldable (Joker g :: * -> * -> *)

Defined in Data.Bifunctor.Joker

Methods

bifold :: Monoid m => Joker g m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Joker g a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Joker g a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Joker g a b -> c

Bifoldable p => Bifoldable (Flip p)

Defined in Data.Bifunctor.Flip

Methods

bifold :: Monoid m => Flip p m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Flip p a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Flip p a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Flip p a b -> c

Foldable f => Bifoldable (Clown f :: * -> * -> *)

Defined in Data.Bifunctor.Clown

Methods

bifold :: Monoid m => Clown f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Clown f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Clown f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Clown f a b -> c

Bifoldable ((,,,,,) x y z w)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, y, z, w, m, m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, z, w, a, b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, z, w, a, b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, z, w, a, b) -> c

(Bifoldable p, Bifoldable q) => Bifoldable (Sum p q)

Defined in Data.Bifunctor.Sum

Methods

bifold :: Monoid m => Sum p q m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Sum p q a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Sum p q a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Sum p q a b -> c

(Bifoldable f, Bifoldable g) => Bifoldable (Product f g)

Defined in Data.Bifunctor.Product

Methods

bifold :: Monoid m => Product f g m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Product f g a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Product f g a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Product f g a b -> c

Bifoldable ((,,,,,,) x y z w v)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => (x, y, z, w, v, m, m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (x, y, z, w, v, a, b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (x, y, z, w, v, a, b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (x, y, z, w, v, a, b) -> c

(Foldable f, Bifoldable p) => Bifoldable (Tannen f p)

Defined in Data.Bifunctor.Tannen

Methods

bifold :: Monoid m => Tannen f p m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Tannen f p a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Tannen f p a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Tannen f p a b -> c

(Bifoldable p, Foldable f, Foldable g) => Bifoldable (Biff p f g)

Defined in Data.Bifunctor.Biff

Methods

bifold :: Monoid m => Biff p f g m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Biff p f g a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Biff p f g a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Biff p f g a b -> c

bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c

As bifoldr, but strict in the result of the reduction functions at each step.

Since: base-4.10.0.0

bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c

Right associative monadic bifold over a structure.

Since: base-4.10.0.0

bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a

As bifoldl, but strict in the result of the reduction functions at each step.

This ensures that each step of the bifold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single, monolithic result (e.g., bilength).

Since: base-4.10.0.0

bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a

Left associative monadic bifold over a structure.

Since: base-4.10.0.0

bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()

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.

Since: base-4.10.0.0

bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()

As bitraverse_, but with the structure as the primary argument. For a version that doesn't ignore the results, see bifor.

>>> > bifor_ ('a', "bc") print (print . reverse)
'a'
"cb"

Since: base-4.10.0.0

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

Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results, see bisequence.

Since: base-4.10.0.0

biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a

The sum of a collection of actions, generalizing biconcat.

Since: base-4.10.0.0

biList :: Bifoldable t => t a a -> [a]

Collects the list of elements of a structure, from left to right.

Since: base-4.10.0.0

binull :: Bifoldable t => t a b -> Bool

Test whether the structure is empty.

Since: base-4.10.0.0

bilength :: Bifoldable t => t a b -> Int

Returns the size/length of a finite structure as an Int.

Since: base-4.10.0.0

bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool

Does the element occur in the structure?

Since: base-4.10.0.0

bisum :: (Bifoldable t, Num a) => t a a -> a

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

Since: base-4.10.0.0

biproduct :: (Bifoldable t, Num a) => t a a -> a

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

Since: base-4.10.0.0

biconcatMap :: Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c]

Given a means of mapping the elements of a structure to lists, computes the concatenation of all such lists in order.

Since: base-4.10.0.0

biand :: Bifoldable t => t Bool Bool -> Bool

biand 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.

Since: base-4.10.0.0

bior :: Bifoldable t => t Bool Bool -> Bool

bior 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.

Since: base-4.10.0.0

biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool

Determines whether any element of the structure satisfies its appropriate predicate argument.

Since: base-4.10.0.0

biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool

Determines whether all elements of the structure satisfy their appropriate predicate argument.

Since: base-4.10.0.0

binotElem :: (Bifoldable t, Eq a) => a -> t a a -> Bool

binotElem is the negation of bielem.

Since: base-4.10.0.0

bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a

The bifind function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

Since: base-4.10.0.0

Bifoldable1

class Bifoldable t => Bifoldable1 (t :: * -> * -> *) where

Methods

bifold1 :: Semigroup m => t m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> t a b -> m

Instances

Bifoldable1 Either

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Either m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Either a b -> m

Bifoldable1 (,)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => (m, m) -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (a, b) -> m

Bifoldable1 Arg

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Arg m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Arg a b -> m

Bifoldable1 ((,,) x)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => (x, m, m) -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, a, b) -> m

Bifoldable1 (Const :: * -> * -> *)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Const m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Const a b -> m

Bifoldable1 (Tagged :: * -> * -> *)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Tagged m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Tagged a b -> m

Bifoldable1 ((,,,) x y)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => (x, y, m, m) -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, y, a, b) -> m

Bifoldable1 ((,,,,) x y z)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => (x, y, z, m, m) -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, y, z, a, b) -> m

Bifoldable1 p => Bifoldable1 (WrappedBifunctor p)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => WrappedBifunctor p m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> WrappedBifunctor p a b -> m

Foldable1 g => Bifoldable1 (Joker g :: * -> * -> *)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Joker g m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Joker g a b -> m

Bifoldable1 p => Bifoldable1 (Flip p)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Flip p m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Flip p a b -> m

Foldable1 f => Bifoldable1 (Clown f :: * -> * -> *)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Clown f m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Clown f a b -> m

(Bifoldable1 f, Bifoldable1 g) => Bifoldable1 (Product f g)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Product f g m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Product f g a b -> m

(Foldable1 f, Bifoldable1 p) => Bifoldable1 (Tannen f p)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Tannen f p m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Tannen f p a b -> m

(Bifoldable1 p, Foldable1 f, Foldable1 g) => Bifoldable1 (Biff p f g)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Biff p f g m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Biff p f g a b -> m

bitraverse1_ :: (Bifoldable1 t, Apply f) => (a -> f b) -> (c -> f d) -> t a c -> f ()

bifor1_ :: (Bifoldable1 t, Apply f) => t a c -> (a -> f b) -> (c -> f d) -> f ()

bisequenceA1_ :: (Bifoldable1 t, Apply f) => t (f a) (f b) -> f ()