Copyright | (C) 2011-2016 Edward Kmett |
---|---|
License | BSD-style (see the file LICENSE) |
Maintainer | libraries@haskell.org |
Stability | provisional |
Portability | portable |
Safe Haskell | Safe |
Language | Haskell2010 |
Since: 4.10.0.0
- class Bifoldable p where
- bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
- bifoldr1 :: Bifoldable t => (a -> a -> a) -> t a a -> a
- bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
- bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
- bifoldl1 :: Bifoldable t => (a -> a -> a) -> t a a -> a
- bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
- bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
- bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
- bimapM_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
- biforM_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
- bimsum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
- bisequenceA_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
- bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
- biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
- biList :: Bifoldable t => t a a -> [a]
- binull :: Bifoldable t => t a b -> Bool
- bilength :: Bifoldable t => t a b -> Int
- bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
- bimaximum :: forall t a. (Bifoldable t, Ord a) => t a a -> a
- biminimum :: forall t a. (Bifoldable t, Ord a) => t a a -> a
- bisum :: (Bifoldable t, Num a) => t a a -> a
- biproduct :: (Bifoldable t, Num a) => t a a -> a
- biconcat :: Bifoldable t => t [a] [a] -> [a]
- biconcatMap :: Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c]
- biand :: Bifoldable t => t Bool Bool -> Bool
- bior :: Bifoldable t => t Bool Bool -> Bool
- biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- bimaximumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a
- biminimumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a
- binotElem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
- bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a
Documentation
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: 4.10.0.0
bifold :: Monoid m => p m m -> m #
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: 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: 4.10.0.0
bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c #
Combines the elments of a structure in a left 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:
bifoldl
f g z ≡foldl
(acc ->either
(f acc) (g acc)) z . toEitherList
Note that if you want an efficient left-fold, you probably want to use
bifoldl'
instead of bifoldl
. The reason is that the latter does not
force the "inner" results, resulting in a thunk chain which then must be
evaluated from the outside-in.
Since: 4.10.0.0
Bifoldable Either # | Since: 4.10.0.0 |
Bifoldable (,) # | Since: 4.10.0.0 |
Bifoldable Arg # | Since: 4.10.0.0 |
Bifoldable ((,,) x) # | Since: 4.10.0.0 |
Bifoldable (Const *) # | Since: 4.10.0.0 |
Bifoldable (K1 * i) # | Since: 4.10.0.0 |
Bifoldable ((,,,) x y) # | Since: 4.10.0.0 |
Bifoldable ((,,,,) x y z) # | Since: 4.10.0.0 |
Bifoldable ((,,,,,) x y z w) # | Since: 4.10.0.0 |
Bifoldable ((,,,,,,) x y z w v) # | Since: 4.10.0.0 |
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: 4.10.0.0
bifoldr1 :: Bifoldable t => (a -> a -> a) -> t a a -> a #
A variant of bifoldr
that has no base case,
and thus may only be applied to non-empty structures.
Since: 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: 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: 4.10.0.0
bifoldl1 :: Bifoldable t => (a -> a -> a) -> t a a -> a #
A variant of bifoldl
that has no base case,
and thus may only be applied to non-empty structures.
Since: 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: 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: 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: 4.10.0.0
bimapM_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f () #
Alias for bitraverse_
.
Since: 4.10.0.0
biforM_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f () #
Alias for bifor_
.
Since: 4.10.0.0
bimsum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a #
Alias for biasum
.
Since: 4.10.0.0
bisequenceA_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f () #
Alias for bisequence_
.
Since: 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: 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: 4.10.0.0
biList :: Bifoldable t => t a a -> [a] #
Collects the list of elements of a structure, from left to right.
Since: 4.10.0.0
binull :: Bifoldable t => t a b -> Bool #
Test whether the structure is empty.
Since: 4.10.0.0
bilength :: Bifoldable t => t a b -> Int #
Returns the size/length of a finite structure as an Int
.
Since: 4.10.0.0
bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool #
Does the element occur in the structure?
Since: 4.10.0.0
bimaximum :: forall t a. (Bifoldable t, Ord a) => t a a -> a #
The largest element of a non-empty structure.
Since: 4.10.0.0
biminimum :: forall t a. (Bifoldable t, Ord a) => t a a -> a #
The least element of a non-empty structure.
Since: 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: 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: 4.10.0.0
biconcat :: Bifoldable t => t [a] [a] -> [a] #
Reduces a structure of lists to the concatenation of those lists.
Since: 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: 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: 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: 4.10.0.0
bimaximumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a #
The largest element of a non-empty structure with respect to the given comparison function.
Since: 4.10.0.0
biminimumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a #
The least element of a non-empty structure with respect to the given comparison function.
Since: 4.10.0.0
binotElem :: (Bifoldable t, Eq a) => a -> t a a -> Bool #