Safe Haskell	Safe
Language	Haskell2010

Papa.Bifunctors.Export

Synopsis

Documentation

class Bifunctor p => Biapplicative p where #

Minimal complete definition

bipure, (<<*>>)

Methods

bipure :: a -> b -> p a b #

(<<*>>) :: p (a -> b) (c -> d) -> p a c -> p b d infixl 4 #

(*>>) :: p a b -> p c d -> p c d infixl 4 #

a *>> b ≡ bimap (const id) (const id) <<$>> a <<*>> b

(<<*) :: p a b -> p c d -> p a b infixl 4 #

a <<* b ≡ bimap const const <<$>> a <<*>> b

Instances

Biapplicative (,)
Methods bipure :: a -> b -> (a, b) # (<<>>) :: (a -> b, c -> d) -> (a, c) -> (b, d) # (>>) :: (a, b) -> (c, d) -> (c, d) # (<<*) :: (a, b) -> (c, d) -> (a, b) #
Biapplicative Arg
Methods bipure :: a -> b -> Arg a b # (<<>>) :: Arg (a -> b) (c -> d) -> Arg a c -> Arg b d # (>>) :: Arg a b -> Arg c d -> Arg c d # (<<*) :: Arg a b -> Arg c d -> Arg a b #
Monoid x => Biapplicative ((,,) x)
Methods bipure :: a -> b -> (x, a, b) # (<<>>) :: (x, a -> b, c -> d) -> (x, a, c) -> (x, b, d) # (>>) :: (x, a, b) -> (x, c, d) -> (x, c, d) # (<<*) :: (x, a, b) -> (x, c, d) -> (x, a, b) #
Biapplicative (Const *)
Methods bipure :: a -> b -> Const * a b # (<<>>) :: Const (a -> b) (c -> d) -> Const * a c -> Const * b d # (>>) :: Const a b -> Const * c d -> Const * c d # (<<) :: Const a b -> Const * c d -> Const * a b #
Biapplicative (Tagged *)
Methods bipure :: a -> b -> Tagged * a b # (<<>>) :: Tagged (a -> b) (c -> d) -> Tagged * a c -> Tagged * b d # (>>) :: Tagged a b -> Tagged * c d -> Tagged * c d # (<<) :: Tagged a b -> Tagged * c d -> Tagged * a b #
(Monoid x, Monoid y) => Biapplicative ((,,,) x y)
Methods bipure :: a -> b -> (x, y, a, b) # (<<>>) :: (x, y, a -> b, c -> d) -> (x, y, a, c) -> (x, y, b, d) # (>>) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, c, d) # (<<*) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, a, b) #
(Monoid x, Monoid y, Monoid z) => Biapplicative ((,,,,) x y z)
Methods bipure :: a -> b -> (x, y, z, a, b) # (<<>>) :: (x, y, z, a -> b, c -> d) -> (x, y, z, a, c) -> (x, y, z, b, d) # (>>) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, c, d) # (<<*) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, a, b) #
Biapplicative p => Biapplicative (WrappedBifunctor * * p)
Methods bipure :: a -> b -> WrappedBifunctor * * p a b # (<<>>) :: WrappedBifunctor * p (a -> b) (c -> d) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b d # (>>) :: WrappedBifunctor * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p c d # (<<) :: WrappedBifunctor * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p a b #
Applicative g => Biapplicative (Joker * * g)
Methods bipure :: a -> b -> Joker * * g a b # (<<>>) :: Joker * g (a -> b) (c -> d) -> Joker * * g a c -> Joker * * g b d # (>>) :: Joker * g a b -> Joker * * g c d -> Joker * * g c d # (<<) :: Joker * g a b -> Joker * * g c d -> Joker * * g a b #
Biapplicative p => Biapplicative (Flip * * p)
Methods bipure :: a -> b -> Flip * * p a b # (<<>>) :: Flip * p (a -> b) (c -> d) -> Flip * * p a c -> Flip * * p b d # (>>) :: Flip * p a b -> Flip * * p c d -> Flip * * p c d # (<<) :: Flip * p a b -> Flip * * p c d -> Flip * * p a b #
Applicative f => Biapplicative (Clown * * f)
Methods bipure :: a -> b -> Clown * * f a b # (<<>>) :: Clown * f (a -> b) (c -> d) -> Clown * * f a c -> Clown * * f b d # (>>) :: Clown * f a b -> Clown * * f c d -> Clown * * f c d # (<<) :: Clown * f a b -> Clown * * f c d -> Clown * * f a b #
(Monoid x, Monoid y, Monoid z, Monoid w) => Biapplicative ((,,,,,) x y z w)
Methods bipure :: a -> b -> (x, y, z, w, a, b) # (<<>>) :: (x, y, z, w, a -> b, c -> d) -> (x, y, z, w, a, c) -> (x, y, z, w, b, d) # (>>) :: (x, y, z, w, a, b) -> (x, y, z, w, c, d) -> (x, y, z, w, c, d) # (<<*) :: (x, y, z, w, a, b) -> (x, y, z, w, c, d) -> (x, y, z, w, a, b) #
(Monoid x, Monoid y, Monoid z, Monoid w, Monoid v) => Biapplicative ((,,,,,,) x y z w v)
Methods bipure :: a -> b -> (x, y, z, w, v, a, b) # (<<>>) :: (x, y, z, w, v, a -> b, c -> d) -> (x, y, z, w, v, a, c) -> (x, y, z, w, v, b, d) # (>>) :: (x, y, z, w, v, a, b) -> (x, y, z, w, v, c, d) -> (x, y, z, w, v, c, d) # (<<*) :: (x, y, z, w, v, a, b) -> (x, y, z, w, v, c, d) -> (x, y, z, w, v, a, b) #
(Applicative f, Biapplicative p) => Biapplicative (Tannen * * * f p)
Methods bipure :: a -> b -> Tannen * * * f p a b # (<<>>) :: Tannen * * f p (a -> b) (c -> d) -> Tannen * * * f p a c -> Tannen * * * f p b d # (>>) :: Tannen * * f p a b -> Tannen * * * f p c d -> Tannen * * * f p c d # (<<) :: Tannen * * f p a b -> Tannen * * * f p c d -> Tannen * * * f p a b #
(Biapplicative p, Applicative f, Applicative g) => Biapplicative (Biff * * * * p f g)
Methods bipure :: a -> b -> Biff * * * * p f g a b # (<<>>) :: Biff * * * p f g (a -> b) (c -> d) -> Biff * * * * p f g a c -> Biff * * * * p f g b d # (>>) :: Biff * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g c d # (<<) :: Biff * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g a b #

(<<$>>) :: (a -> b) -> a -> b infixl 4 #

(<<**>>) :: Biapplicative p => p a c -> p (a -> b) (c -> d) -> p b d infixl 4 #

biliftA2 :: Biapplicative w => (a -> b -> c) -> (d -> e -> f) -> w a d -> w b e -> w c f #

Lift binary functions

biliftA3 :: Biapplicative w => (a -> b -> c -> d) -> (e -> f -> g -> h) -> w a e -> w b f -> w c g -> w d h #

Lift ternary functions

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)

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

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

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

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.

Instances

Bifoldable Either
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 (,)
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
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 (K1 i)
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)
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 *)
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 #
Bifoldable (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 (Constant *)
Methods bifold :: Monoid m => Constant * m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Constant * a b -> m # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Constant * a b -> c # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Constant * a b -> c #
Bifoldable ((,,,) x y)
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)
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)
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)
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)
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)
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)
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 ((,,,,,,) x y z w v)
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)
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)
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 p => forall a c b. (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

bifoldl :: Bifoldable p => forall c a b. (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.

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.

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.

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

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.

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.

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"

bimapM_ :: (Bifoldable t, Monad m) => (a -> m c) -> (b -> m d) -> t a b -> m () #

As bimapM, but ignores the results of the functions, merely performing the "actions".

biforM_ :: (Bifoldable t, Monad m) => t a b -> (a -> m c) -> (b -> m d) -> m () #

As bimapM_, but with the structure as the primary argument.

bimsum :: (Bifoldable t, MonadPlus m) => t (m a) (m a) -> m a #

The sum of a collection of actions, generalizing biconcat.

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

As bisequenceA, but ignores the results of the actions.

bisequence_ :: (Bifoldable t, Monad m) => t (m a) (m b) -> 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 bisequence.

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

The sum of a collection of actions, generalizing biconcat.

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

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

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

Test whether the structure is empty.

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

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

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

Does the element occur in the structure?

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

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

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

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

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.

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.

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

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

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

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

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

binotElem is the negation of bielem.

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.

data Biff k k1 k2 k3 p f g a b :: forall k k1 k2 k3. (k3 -> k2 -> *) -> (k1 -> k3) -> (k -> k2) -> k1 -> k -> * #

Compose two Functors on the inside of a Bifunctor.

Instances

(Bifunctor p, Functor f, Functor g) => Bifunctor (Biff * * * * p f g)
Methods bimap :: (a -> b) -> (c -> d) -> Biff * * * * p f g a c -> Biff * * * * p f g b d # first :: (a -> b) -> Biff * * * * p f g a c -> Biff * * * * p f g b c # second :: (b -> c) -> Biff * * * * p f g a b -> Biff * * * * p f g a c #
(Biapplicative p, Applicative f, Applicative g) => Biapplicative (Biff * * * * p f g)
Methods bipure :: a -> b -> Biff * * * * p f g a b # (<<>>) :: Biff * * * p f g (a -> b) (c -> d) -> Biff * * * * p f g a c -> Biff * * * * p f g b d # (>>) :: Biff * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g c d # (<<) :: Biff * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g a b #
(Bitraversable p, Traversable f, Traversable g) => Bitraversable (Biff * * * * p f g)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Biff * * * * p f g a b -> f (Biff * * * * p f g c d) #
(Bifoldable p, Foldable f, Foldable g) => Bifoldable (Biff * * * * p f g)
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 #
(Bifunctor p, Functor g) => Functor (Biff * k * * p f g a)
Methods fmap :: (a -> b) -> Biff * k * * p f g a a -> Biff * k * * p f g a b # (<$) :: a -> Biff * k * * p f g a b -> Biff * k * * p f g a a #
(Bifoldable p, Foldable g) => Foldable (Biff * k * * p f g a)
Methods fold :: Monoid m => Biff * k * * p f g a m -> m # foldMap :: Monoid m => (a -> m) -> Biff * k * * p f g a a -> m # foldr :: (a -> b -> b) -> b -> Biff * k * * p f g a a -> b # foldr' :: (a -> b -> b) -> b -> Biff * k * * p f g a a -> b # foldl :: (b -> a -> b) -> b -> Biff * k * * p f g a a -> b # foldl' :: (b -> a -> b) -> b -> Biff * k * * p f g a a -> b # foldr1 :: (a -> a -> a) -> Biff * k * * p f g a a -> a # foldl1 :: (a -> a -> a) -> Biff * k * * p f g a a -> a # toList :: Biff * k * * p f g a a -> [a] # null :: Biff * k * * p f g a a -> Bool # length :: Biff * k * * p f g a a -> Int # elem :: Eq a => a -> Biff * k * * p f g a a -> Bool # maximum :: Ord a => Biff * k * * p f g a a -> a # minimum :: Ord a => Biff * k * * p f g a a -> a # sum :: Num a => Biff * k * * p f g a a -> a # product :: Num a => Biff * k * * p f g a a -> a #
(Bitraversable p, Traversable g) => Traversable (Biff * k * * p f g a)
Methods traverse :: Applicative f => (a -> f b) -> Biff * k * * p f g a a -> f (Biff * k * * p f g a b) # sequenceA :: Applicative f => Biff * k * * p f g a (f a) -> f (Biff * k * * p f g a a) # mapM :: Monad m => (a -> m b) -> Biff * k * * p f g a a -> m (Biff * k * * p f g a b) # sequence :: Monad m => Biff * k * * p f g a (m a) -> m (Biff * k * * p f g a a) #
Functor (p (f a)) => Generic1 (Biff * k * k1 p f g a)
Associated Types type Rep1 (Biff * k * k1 p f g a :: * -> ) :: -> * # Methods from1 :: Biff * k * k1 p f g a a -> Rep1 (Biff * k * k1 p f g a) a # to1 :: Rep1 (Biff * k * k1 p f g a) a -> Biff * k * k1 p f g a a #
Eq (p (f a) (g b)) => Eq (Biff k3 k2 k1 k p f g a b)
Methods (==) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (/=) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool #
Ord (p (f a) (g b)) => Ord (Biff k3 k2 k1 k p f g a b)
Methods compare :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Ordering # (<) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (<=) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (>) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (>=) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # max :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b # min :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b #
Read (p (f a) (g b)) => Read (Biff k3 k2 k1 k p f g a b)
Methods readsPrec :: Int -> ReadS (Biff k3 k2 k1 k p f g a b) # readList :: ReadS [Biff k3 k2 k1 k p f g a b] # readPrec :: ReadPrec (Biff k3 k2 k1 k p f g a b) # readListPrec :: ReadPrec [Biff k3 k2 k1 k p f g a b] #
Show (p (f a) (g b)) => Show (Biff k3 k2 k1 k p f g a b)
Methods showsPrec :: Int -> Biff k3 k2 k1 k p f g a b -> ShowS # show :: Biff k3 k2 k1 k p f g a b -> String # showList :: [Biff k3 k2 k1 k p f g a b] -> ShowS #
Generic (Biff k3 k2 k1 k p f g a b)
Associated Types type Rep (Biff k3 k2 k1 k p f g a b) :: * -> * # Methods from :: Biff k3 k2 k1 k p f g a b -> Rep (Biff k3 k2 k1 k p f g a b) x # to :: Rep (Biff k3 k2 k1 k p f g a b) x -> Biff k3 k2 k1 k p f g a b #
type Rep1 (Biff * k1 * k p f g a)
type Rep1 (Biff * k1 * k p f g a) = D1 (MetaData "Biff" "Data.Bifunctor.Biff" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Biff" PrefixI True) (S1 (MetaSel (Just Symbol "runBiff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) (p (f a)) (Rec1 g))))
type Rep (Biff k3 k2 k1 k p f g a b)
type Rep (Biff k3 k2 k1 k p f g a b) = D1 (MetaData "Biff" "Data.Bifunctor.Biff" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Biff" PrefixI True) (S1 (MetaSel (Just Symbol "runBiff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p (f a) (g b)))))

data Biff k k1 k2 k3 p f g a b :: forall k k1 k2 k3. (k3 -> k2 -> *) -> (k1 -> k3) -> (k -> k2) -> k1 -> k -> * #

Compose two Functors on the inside of a Bifunctor.

Instances

(Bifunctor p, Functor f, Functor g) => Bifunctor (Biff * * * * p f g)
Methods bimap :: (a -> b) -> (c -> d) -> Biff * * * * p f g a c -> Biff * * * * p f g b d # first :: (a -> b) -> Biff * * * * p f g a c -> Biff * * * * p f g b c # second :: (b -> c) -> Biff * * * * p f g a b -> Biff * * * * p f g a c #
(Biapplicative p, Applicative f, Applicative g) => Biapplicative (Biff * * * * p f g)
Methods bipure :: a -> b -> Biff * * * * p f g a b # (<<>>) :: Biff * * * p f g (a -> b) (c -> d) -> Biff * * * * p f g a c -> Biff * * * * p f g b d # (>>) :: Biff * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g c d # (<<) :: Biff * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g a b #
(Bitraversable p, Traversable f, Traversable g) => Bitraversable (Biff * * * * p f g)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Biff * * * * p f g a b -> f (Biff * * * * p f g c d) #
(Bifoldable p, Foldable f, Foldable g) => Bifoldable (Biff * * * * p f g)
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 #
(Bifunctor p, Functor g) => Functor (Biff * k * * p f g a)
Methods fmap :: (a -> b) -> Biff * k * * p f g a a -> Biff * k * * p f g a b # (<$) :: a -> Biff * k * * p f g a b -> Biff * k * * p f g a a #
(Bifoldable p, Foldable g) => Foldable (Biff * k * * p f g a)
Methods fold :: Monoid m => Biff * k * * p f g a m -> m # foldMap :: Monoid m => (a -> m) -> Biff * k * * p f g a a -> m # foldr :: (a -> b -> b) -> b -> Biff * k * * p f g a a -> b # foldr' :: (a -> b -> b) -> b -> Biff * k * * p f g a a -> b # foldl :: (b -> a -> b) -> b -> Biff * k * * p f g a a -> b # foldl' :: (b -> a -> b) -> b -> Biff * k * * p f g a a -> b # foldr1 :: (a -> a -> a) -> Biff * k * * p f g a a -> a # foldl1 :: (a -> a -> a) -> Biff * k * * p f g a a -> a # toList :: Biff * k * * p f g a a -> [a] # null :: Biff * k * * p f g a a -> Bool # length :: Biff * k * * p f g a a -> Int # elem :: Eq a => a -> Biff * k * * p f g a a -> Bool # maximum :: Ord a => Biff * k * * p f g a a -> a # minimum :: Ord a => Biff * k * * p f g a a -> a # sum :: Num a => Biff * k * * p f g a a -> a # product :: Num a => Biff * k * * p f g a a -> a #
(Bitraversable p, Traversable g) => Traversable (Biff * k * * p f g a)
Methods traverse :: Applicative f => (a -> f b) -> Biff * k * * p f g a a -> f (Biff * k * * p f g a b) # sequenceA :: Applicative f => Biff * k * * p f g a (f a) -> f (Biff * k * * p f g a a) # mapM :: Monad m => (a -> m b) -> Biff * k * * p f g a a -> m (Biff * k * * p f g a b) # sequence :: Monad m => Biff * k * * p f g a (m a) -> m (Biff * k * * p f g a a) #
Functor (p (f a)) => Generic1 (Biff * k * k1 p f g a)
Associated Types type Rep1 (Biff * k * k1 p f g a :: * -> ) :: -> * # Methods from1 :: Biff * k * k1 p f g a a -> Rep1 (Biff * k * k1 p f g a) a # to1 :: Rep1 (Biff * k * k1 p f g a) a -> Biff * k * k1 p f g a a #
Eq (p (f a) (g b)) => Eq (Biff k3 k2 k1 k p f g a b)
Methods (==) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (/=) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool #
Ord (p (f a) (g b)) => Ord (Biff k3 k2 k1 k p f g a b)
Methods compare :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Ordering # (<) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (<=) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (>) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (>=) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # max :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b # min :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b #
Read (p (f a) (g b)) => Read (Biff k3 k2 k1 k p f g a b)
Methods readsPrec :: Int -> ReadS (Biff k3 k2 k1 k p f g a b) # readList :: ReadS [Biff k3 k2 k1 k p f g a b] # readPrec :: ReadPrec (Biff k3 k2 k1 k p f g a b) # readListPrec :: ReadPrec [Biff k3 k2 k1 k p f g a b] #
Show (p (f a) (g b)) => Show (Biff k3 k2 k1 k p f g a b)
Methods showsPrec :: Int -> Biff k3 k2 k1 k p f g a b -> ShowS # show :: Biff k3 k2 k1 k p f g a b -> String # showList :: [Biff k3 k2 k1 k p f g a b] -> ShowS #
Generic (Biff k3 k2 k1 k p f g a b)
Associated Types type Rep (Biff k3 k2 k1 k p f g a b) :: * -> * # Methods from :: Biff k3 k2 k1 k p f g a b -> Rep (Biff k3 k2 k1 k p f g a b) x # to :: Rep (Biff k3 k2 k1 k p f g a b) x -> Biff k3 k2 k1 k p f g a b #
type Rep1 (Biff * k1 * k p f g a)
type Rep1 (Biff * k1 * k p f g a) = D1 (MetaData "Biff" "Data.Bifunctor.Biff" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Biff" PrefixI True) (S1 (MetaSel (Just Symbol "runBiff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) (p (f a)) (Rec1 g))))
type Rep (Biff k3 k2 k1 k p f g a b)
type Rep (Biff k3 k2 k1 k p f g a b) = D1 (MetaData "Biff" "Data.Bifunctor.Biff" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Biff" PrefixI True) (S1 (MetaSel (Just Symbol "runBiff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p (f a) (g b)))))

data Clown k k1 f a b :: forall k k1. (k1 -> *) -> k1 -> k -> * #

Make a Functor over the first argument of a Bifunctor.

Mnemonic: Clowns to the left (parameter of the Bifunctor), jokers to the right.

Instances

Functor f => Bifunctor (Clown * * f)
Methods bimap :: (a -> b) -> (c -> d) -> Clown * * f a c -> Clown * * f b d # first :: (a -> b) -> Clown * * f a c -> Clown * * f b c # second :: (b -> c) -> Clown * * f a b -> Clown * * f a c #
Applicative f => Biapplicative (Clown * * f)
Methods bipure :: a -> b -> Clown * * f a b # (<<>>) :: Clown * f (a -> b) (c -> d) -> Clown * * f a c -> Clown * * f b d # (>>) :: Clown * f a b -> Clown * * f c d -> Clown * * f c d # (<<) :: Clown * f a b -> Clown * * f c d -> Clown * * f a b #
Traversable f => Bitraversable (Clown * * f)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Clown * * f a b -> f (Clown * * f c d) #
Foldable f => Bifoldable (Clown * * f)
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 #
Functor (Clown * k f a)
Methods fmap :: (a -> b) -> Clown * k f a a -> Clown * k f a b # (<$) :: a -> Clown * k f a b -> Clown * k f a a #
Foldable (Clown * k f a)
Methods fold :: Monoid m => Clown * k f a m -> m # foldMap :: Monoid m => (a -> m) -> Clown * k f a a -> m # foldr :: (a -> b -> b) -> b -> Clown * k f a a -> b # foldr' :: (a -> b -> b) -> b -> Clown * k f a a -> b # foldl :: (b -> a -> b) -> b -> Clown * k f a a -> b # foldl' :: (b -> a -> b) -> b -> Clown * k f a a -> b # foldr1 :: (a -> a -> a) -> Clown * k f a a -> a # foldl1 :: (a -> a -> a) -> Clown * k f a a -> a # toList :: Clown * k f a a -> [a] # null :: Clown * k f a a -> Bool # length :: Clown * k f a a -> Int # elem :: Eq a => a -> Clown * k f a a -> Bool # maximum :: Ord a => Clown * k f a a -> a # minimum :: Ord a => Clown * k f a a -> a # sum :: Num a => Clown * k f a a -> a # product :: Num a => Clown * k f a a -> a #
Traversable (Clown * k f a)
Methods traverse :: Applicative f => (a -> f b) -> Clown * k f a a -> f (Clown * k f a b) # sequenceA :: Applicative f => Clown * k f a (f a) -> f (Clown * k f a a) # mapM :: Monad m => (a -> m b) -> Clown * k f a a -> m (Clown * k f a b) # sequence :: Monad m => Clown * k f a (m a) -> m (Clown * k f a a) #
Generic1 (Clown * k f a)
Associated Types type Rep1 (Clown * k f a :: * -> ) :: -> * # Methods from1 :: Clown * k f a a -> Rep1 (Clown * k f a) a # to1 :: Rep1 (Clown * k f a) a -> Clown * k f a a #
Eq (f a) => Eq (Clown k1 k f a b)
Methods (==) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (/=) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool #
Ord (f a) => Ord (Clown k1 k f a b)
Methods compare :: Clown k1 k f a b -> Clown k1 k f a b -> Ordering # (<) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (<=) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (>) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (>=) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # max :: Clown k1 k f a b -> Clown k1 k f a b -> Clown k1 k f a b # min :: Clown k1 k f a b -> Clown k1 k f a b -> Clown k1 k f a b #
Read (f a) => Read (Clown k1 k f a b)
Methods readsPrec :: Int -> ReadS (Clown k1 k f a b) # readList :: ReadS [Clown k1 k f a b] # readPrec :: ReadPrec (Clown k1 k f a b) # readListPrec :: ReadPrec [Clown k1 k f a b] #
Show (f a) => Show (Clown k1 k f a b)
Methods showsPrec :: Int -> Clown k1 k f a b -> ShowS # show :: Clown k1 k f a b -> String # showList :: [Clown k1 k f a b] -> ShowS #
Generic (Clown k1 k f a b)
Associated Types type Rep (Clown k1 k f a b) :: * -> * # Methods from :: Clown k1 k f a b -> Rep (Clown k1 k f a b) x # to :: Rep (Clown k1 k f a b) x -> Clown k1 k f a b #
type Rep1 (Clown * k f a)
type Rep1 (Clown * k f a) = D1 (MetaData "Clown" "Data.Bifunctor.Clown" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Clown" PrefixI True) (S1 (MetaSel (Just Symbol "runClown") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))
type Rep (Clown k1 k f a b)
type Rep (Clown k1 k f a b) = D1 (MetaData "Clown" "Data.Bifunctor.Clown" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Clown" PrefixI True) (S1 (MetaSel (Just Symbol "runClown") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))

data Clown k k1 f a b :: forall k k1. (k1 -> *) -> k1 -> k -> * #

Make a Functor over the first argument of a Bifunctor.

Mnemonic: Clowns to the left (parameter of the Bifunctor), jokers to the right.

Instances

Functor f => Bifunctor (Clown * * f)
Methods bimap :: (a -> b) -> (c -> d) -> Clown * * f a c -> Clown * * f b d # first :: (a -> b) -> Clown * * f a c -> Clown * * f b c # second :: (b -> c) -> Clown * * f a b -> Clown * * f a c #
Applicative f => Biapplicative (Clown * * f)
Methods bipure :: a -> b -> Clown * * f a b # (<<>>) :: Clown * f (a -> b) (c -> d) -> Clown * * f a c -> Clown * * f b d # (>>) :: Clown * f a b -> Clown * * f c d -> Clown * * f c d # (<<) :: Clown * f a b -> Clown * * f c d -> Clown * * f a b #
Traversable f => Bitraversable (Clown * * f)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Clown * * f a b -> f (Clown * * f c d) #
Foldable f => Bifoldable (Clown * * f)
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 #
Functor (Clown * k f a)
Methods fmap :: (a -> b) -> Clown * k f a a -> Clown * k f a b # (<$) :: a -> Clown * k f a b -> Clown * k f a a #
Foldable (Clown * k f a)
Methods fold :: Monoid m => Clown * k f a m -> m # foldMap :: Monoid m => (a -> m) -> Clown * k f a a -> m # foldr :: (a -> b -> b) -> b -> Clown * k f a a -> b # foldr' :: (a -> b -> b) -> b -> Clown * k f a a -> b # foldl :: (b -> a -> b) -> b -> Clown * k f a a -> b # foldl' :: (b -> a -> b) -> b -> Clown * k f a a -> b # foldr1 :: (a -> a -> a) -> Clown * k f a a -> a # foldl1 :: (a -> a -> a) -> Clown * k f a a -> a # toList :: Clown * k f a a -> [a] # null :: Clown * k f a a -> Bool # length :: Clown * k f a a -> Int # elem :: Eq a => a -> Clown * k f a a -> Bool # maximum :: Ord a => Clown * k f a a -> a # minimum :: Ord a => Clown * k f a a -> a # sum :: Num a => Clown * k f a a -> a # product :: Num a => Clown * k f a a -> a #
Traversable (Clown * k f a)
Methods traverse :: Applicative f => (a -> f b) -> Clown * k f a a -> f (Clown * k f a b) # sequenceA :: Applicative f => Clown * k f a (f a) -> f (Clown * k f a a) # mapM :: Monad m => (a -> m b) -> Clown * k f a a -> m (Clown * k f a b) # sequence :: Monad m => Clown * k f a (m a) -> m (Clown * k f a a) #
Generic1 (Clown * k f a)
Associated Types type Rep1 (Clown * k f a :: * -> ) :: -> * # Methods from1 :: Clown * k f a a -> Rep1 (Clown * k f a) a # to1 :: Rep1 (Clown * k f a) a -> Clown * k f a a #
Eq (f a) => Eq (Clown k1 k f a b)
Methods (==) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (/=) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool #
Ord (f a) => Ord (Clown k1 k f a b)
Methods compare :: Clown k1 k f a b -> Clown k1 k f a b -> Ordering # (<) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (<=) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (>) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (>=) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # max :: Clown k1 k f a b -> Clown k1 k f a b -> Clown k1 k f a b # min :: Clown k1 k f a b -> Clown k1 k f a b -> Clown k1 k f a b #
Read (f a) => Read (Clown k1 k f a b)
Methods readsPrec :: Int -> ReadS (Clown k1 k f a b) # readList :: ReadS [Clown k1 k f a b] # readPrec :: ReadPrec (Clown k1 k f a b) # readListPrec :: ReadPrec [Clown k1 k f a b] #
Show (f a) => Show (Clown k1 k f a b)
Methods showsPrec :: Int -> Clown k1 k f a b -> ShowS # show :: Clown k1 k f a b -> String # showList :: [Clown k1 k f a b] -> ShowS #
Generic (Clown k1 k f a b)
Associated Types type Rep (Clown k1 k f a b) :: * -> * # Methods from :: Clown k1 k f a b -> Rep (Clown k1 k f a b) x # to :: Rep (Clown k1 k f a b) x -> Clown k1 k f a b #
type Rep1 (Clown * k f a)
type Rep1 (Clown * k f a) = D1 (MetaData "Clown" "Data.Bifunctor.Clown" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Clown" PrefixI True) (S1 (MetaSel (Just Symbol "runClown") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))
type Rep (Clown k1 k f a b)
type Rep (Clown k1 k f a b) = D1 (MetaData "Clown" "Data.Bifunctor.Clown" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Clown" PrefixI True) (S1 (MetaSel (Just Symbol "runClown") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))

data Fix k p a :: forall k. (* -> k -> *) -> k -> * #

Greatest fixpoint of a Bifunctor (a Functor over the first argument with zipping).

Instances

Bifunctor p => Functor (Fix * p)
Methods fmap :: (a -> b) -> Fix * p a -> Fix * p b # (<$) :: a -> Fix * p b -> Fix * p a #
Biapplicative p => Applicative (Fix * p)
Methods pure :: a -> Fix * p a # (<>) :: Fix p (a -> b) -> Fix * p a -> Fix * p b # (>) :: Fix p a -> Fix * p b -> Fix * p b # (<) :: Fix p a -> Fix * p b -> Fix * p a #
Bifoldable p => Foldable (Fix * p)
Methods fold :: Monoid m => Fix * p m -> m # foldMap :: Monoid m => (a -> m) -> Fix * p a -> m # foldr :: (a -> b -> b) -> b -> Fix * p a -> b # foldr' :: (a -> b -> b) -> b -> Fix * p a -> b # foldl :: (b -> a -> b) -> b -> Fix * p a -> b # foldl' :: (b -> a -> b) -> b -> Fix * p a -> b # foldr1 :: (a -> a -> a) -> Fix * p a -> a # foldl1 :: (a -> a -> a) -> Fix * p a -> a # toList :: Fix * p a -> [a] # null :: Fix * p a -> Bool # length :: Fix * p a -> Int # elem :: Eq a => a -> Fix * p a -> Bool # maximum :: Ord a => Fix * p a -> a # minimum :: Ord a => Fix * p a -> a # sum :: Num a => Fix * p a -> a # product :: Num a => Fix * p a -> a #
Bitraversable p => Traversable (Fix * p)
Methods traverse :: Applicative f => (a -> f b) -> Fix * p a -> f (Fix * p b) # sequenceA :: Applicative f => Fix * p (f a) -> f (Fix * p a) # mapM :: Monad m => (a -> m b) -> Fix * p a -> m (Fix * p b) # sequence :: Monad m => Fix * p (m a) -> m (Fix * p a) #
Eq (p (Fix k p a) a) => Eq (Fix k p a)
Methods (==) :: Fix k p a -> Fix k p a -> Bool # (/=) :: Fix k p a -> Fix k p a -> Bool #
Ord (p (Fix k p a) a) => Ord (Fix k p a)
Methods compare :: Fix k p a -> Fix k p a -> Ordering # (<) :: Fix k p a -> Fix k p a -> Bool # (<=) :: Fix k p a -> Fix k p a -> Bool # (>) :: Fix k p a -> Fix k p a -> Bool # (>=) :: Fix k p a -> Fix k p a -> Bool # max :: Fix k p a -> Fix k p a -> Fix k p a # min :: Fix k p a -> Fix k p a -> Fix k p a #
Read (p (Fix k p a) a) => Read (Fix k p a)
Methods readsPrec :: Int -> ReadS (Fix k p a) # readList :: ReadS [Fix k p a] # readPrec :: ReadPrec (Fix k p a) # readListPrec :: ReadPrec [Fix k p a] #
Show (p (Fix k p a) a) => Show (Fix k p a)
Methods showsPrec :: Int -> Fix k p a -> ShowS # show :: Fix k p a -> String # showList :: [Fix k p a] -> ShowS #
Generic (Fix k p a)
Associated Types type Rep (Fix k p a) :: * -> * # Methods from :: Fix k p a -> Rep (Fix k p a) x # to :: Rep (Fix k p a) x -> Fix k p a #
type Rep (Fix k p a)
type Rep (Fix k p a) = D1 (MetaData "Fix" "Data.Bifunctor.Fix" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "In" PrefixI True) (S1 (MetaSel (Just Symbol "out") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p (Fix k p a) a))))

data Fix k p a :: forall k. (* -> k -> *) -> k -> * #

Greatest fixpoint of a Bifunctor (a Functor over the first argument with zipping).

Instances

Bifunctor p => Functor (Fix * p)
Methods fmap :: (a -> b) -> Fix * p a -> Fix * p b # (<$) :: a -> Fix * p b -> Fix * p a #
Biapplicative p => Applicative (Fix * p)
Methods pure :: a -> Fix * p a # (<>) :: Fix p (a -> b) -> Fix * p a -> Fix * p b # (>) :: Fix p a -> Fix * p b -> Fix * p b # (<) :: Fix p a -> Fix * p b -> Fix * p a #
Bifoldable p => Foldable (Fix * p)
Methods fold :: Monoid m => Fix * p m -> m # foldMap :: Monoid m => (a -> m) -> Fix * p a -> m # foldr :: (a -> b -> b) -> b -> Fix * p a -> b # foldr' :: (a -> b -> b) -> b -> Fix * p a -> b # foldl :: (b -> a -> b) -> b -> Fix * p a -> b # foldl' :: (b -> a -> b) -> b -> Fix * p a -> b # foldr1 :: (a -> a -> a) -> Fix * p a -> a # foldl1 :: (a -> a -> a) -> Fix * p a -> a # toList :: Fix * p a -> [a] # null :: Fix * p a -> Bool # length :: Fix * p a -> Int # elem :: Eq a => a -> Fix * p a -> Bool # maximum :: Ord a => Fix * p a -> a # minimum :: Ord a => Fix * p a -> a # sum :: Num a => Fix * p a -> a # product :: Num a => Fix * p a -> a #
Bitraversable p => Traversable (Fix * p)
Methods traverse :: Applicative f => (a -> f b) -> Fix * p a -> f (Fix * p b) # sequenceA :: Applicative f => Fix * p (f a) -> f (Fix * p a) # mapM :: Monad m => (a -> m b) -> Fix * p a -> m (Fix * p b) # sequence :: Monad m => Fix * p (m a) -> m (Fix * p a) #
Eq (p (Fix k p a) a) => Eq (Fix k p a)
Methods (==) :: Fix k p a -> Fix k p a -> Bool # (/=) :: Fix k p a -> Fix k p a -> Bool #
Ord (p (Fix k p a) a) => Ord (Fix k p a)
Methods compare :: Fix k p a -> Fix k p a -> Ordering # (<) :: Fix k p a -> Fix k p a -> Bool # (<=) :: Fix k p a -> Fix k p a -> Bool # (>) :: Fix k p a -> Fix k p a -> Bool # (>=) :: Fix k p a -> Fix k p a -> Bool # max :: Fix k p a -> Fix k p a -> Fix k p a # min :: Fix k p a -> Fix k p a -> Fix k p a #
Read (p (Fix k p a) a) => Read (Fix k p a)
Methods readsPrec :: Int -> ReadS (Fix k p a) # readList :: ReadS [Fix k p a] # readPrec :: ReadPrec (Fix k p a) # readListPrec :: ReadPrec [Fix k p a] #
Show (p (Fix k p a) a) => Show (Fix k p a)
Methods showsPrec :: Int -> Fix k p a -> ShowS # show :: Fix k p a -> String # showList :: [Fix k p a] -> ShowS #
Generic (Fix k p a)
Associated Types type Rep (Fix k p a) :: * -> * # Methods from :: Fix k p a -> Rep (Fix k p a) x # to :: Rep (Fix k p a) x -> Fix k p a #
type Rep (Fix k p a)
type Rep (Fix k p a) = D1 (MetaData "Fix" "Data.Bifunctor.Fix" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "In" PrefixI True) (S1 (MetaSel (Just Symbol "out") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p (Fix k p a) a))))

data Flip k k1 p a b :: forall k k1. (k1 -> k -> *) -> k -> k1 -> * #

Make a Bifunctor flipping the arguments of a Bifunctor.

Instances

BifunctorFunctor k1 k k k1 (Flip k k1)
Methods bifmap :: (k2 :-> k3) p q -> (Flip k k1 :-> k1) (t p) (t q) #
Bifunctor p => Bifunctor (Flip * * p)
Methods bimap :: (a -> b) -> (c -> d) -> Flip * * p a c -> Flip * * p b d # first :: (a -> b) -> Flip * * p a c -> Flip * * p b c # second :: (b -> c) -> Flip * * p a b -> Flip * * p a c #
Biapplicative p => Biapplicative (Flip * * p)
Methods bipure :: a -> b -> Flip * * p a b # (<<>>) :: Flip * p (a -> b) (c -> d) -> Flip * * p a c -> Flip * * p b d # (>>) :: Flip * p a b -> Flip * * p c d -> Flip * * p c d # (<<) :: Flip * p a b -> Flip * * p c d -> Flip * * p a b #
Bitraversable p => Bitraversable (Flip * * p)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Flip * * p a b -> f (Flip * * p c d) #
Bifoldable p => Bifoldable (Flip * * p)
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 #
Bifunctor p => Functor (Flip * * p a)
Methods fmap :: (a -> b) -> Flip * * p a a -> Flip * * p a b # (<$) :: a -> Flip * * p a b -> Flip * * p a a #
Bifoldable p => Foldable (Flip * * p a)
Methods fold :: Monoid m => Flip * * p a m -> m # foldMap :: Monoid m => (a -> m) -> Flip * * p a a -> m # foldr :: (a -> b -> b) -> b -> Flip * * p a a -> b # foldr' :: (a -> b -> b) -> b -> Flip * * p a a -> b # foldl :: (b -> a -> b) -> b -> Flip * * p a a -> b # foldl' :: (b -> a -> b) -> b -> Flip * * p a a -> b # foldr1 :: (a -> a -> a) -> Flip * * p a a -> a # foldl1 :: (a -> a -> a) -> Flip * * p a a -> a # toList :: Flip * * p a a -> [a] # null :: Flip * * p a a -> Bool # length :: Flip * * p a a -> Int # elem :: Eq a => a -> Flip * * p a a -> Bool # maximum :: Ord a => Flip * * p a a -> a # minimum :: Ord a => Flip * * p a a -> a # sum :: Num a => Flip * * p a a -> a # product :: Num a => Flip * * p a a -> a #
Bitraversable p => Traversable (Flip * * p a)
Methods traverse :: Applicative f => (a -> f b) -> Flip * * p a a -> f (Flip * * p a b) # sequenceA :: Applicative f => Flip * * p a (f a) -> f (Flip * * p a a) # mapM :: Monad m => (a -> m b) -> Flip * * p a a -> m (Flip * * p a b) # sequence :: Monad m => Flip * * p a (m a) -> m (Flip * * p a a) #
Eq (p b a) => Eq (Flip k k1 p a b)
Methods (==) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (/=) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool #
Ord (p b a) => Ord (Flip k k1 p a b)
Methods compare :: Flip k k1 p a b -> Flip k k1 p a b -> Ordering # (<) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (<=) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (>) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (>=) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # max :: Flip k k1 p a b -> Flip k k1 p a b -> Flip k k1 p a b # min :: Flip k k1 p a b -> Flip k k1 p a b -> Flip k k1 p a b #
Read (p b a) => Read (Flip k k1 p a b)
Methods readsPrec :: Int -> ReadS (Flip k k1 p a b) # readList :: ReadS [Flip k k1 p a b] # readPrec :: ReadPrec (Flip k k1 p a b) # readListPrec :: ReadPrec [Flip k k1 p a b] #
Show (p b a) => Show (Flip k k1 p a b)
Methods showsPrec :: Int -> Flip k k1 p a b -> ShowS # show :: Flip k k1 p a b -> String # showList :: [Flip k k1 p a b] -> ShowS #
Generic (Flip k k1 p a b)
Associated Types type Rep (Flip k k1 p a b) :: * -> * # Methods from :: Flip k k1 p a b -> Rep (Flip k k1 p a b) x # to :: Rep (Flip k k1 p a b) x -> Flip k k1 p a b #
type Rep (Flip k k1 p a b)
type Rep (Flip k k1 p a b) = D1 (MetaData "Flip" "Data.Bifunctor.Flip" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Flip" PrefixI True) (S1 (MetaSel (Just Symbol "runFlip") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p b a))))

data Flip k k1 p a b :: forall k k1. (k1 -> k -> *) -> k -> k1 -> * #

Make a Bifunctor flipping the arguments of a Bifunctor.

Instances

BifunctorFunctor k1 k k k1 (Flip k k1)
Methods bifmap :: (k2 :-> k3) p q -> (Flip k k1 :-> k1) (t p) (t q) #
Bifunctor p => Bifunctor (Flip * * p)
Methods bimap :: (a -> b) -> (c -> d) -> Flip * * p a c -> Flip * * p b d # first :: (a -> b) -> Flip * * p a c -> Flip * * p b c # second :: (b -> c) -> Flip * * p a b -> Flip * * p a c #
Biapplicative p => Biapplicative (Flip * * p)
Methods bipure :: a -> b -> Flip * * p a b # (<<>>) :: Flip * p (a -> b) (c -> d) -> Flip * * p a c -> Flip * * p b d # (>>) :: Flip * p a b -> Flip * * p c d -> Flip * * p c d # (<<) :: Flip * p a b -> Flip * * p c d -> Flip * * p a b #
Bitraversable p => Bitraversable (Flip * * p)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Flip * * p a b -> f (Flip * * p c d) #
Bifoldable p => Bifoldable (Flip * * p)
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 #
Bifunctor p => Functor (Flip * * p a)
Methods fmap :: (a -> b) -> Flip * * p a a -> Flip * * p a b # (<$) :: a -> Flip * * p a b -> Flip * * p a a #
Bifoldable p => Foldable (Flip * * p a)
Methods fold :: Monoid m => Flip * * p a m -> m # foldMap :: Monoid m => (a -> m) -> Flip * * p a a -> m # foldr :: (a -> b -> b) -> b -> Flip * * p a a -> b # foldr' :: (a -> b -> b) -> b -> Flip * * p a a -> b # foldl :: (b -> a -> b) -> b -> Flip * * p a a -> b # foldl' :: (b -> a -> b) -> b -> Flip * * p a a -> b # foldr1 :: (a -> a -> a) -> Flip * * p a a -> a # foldl1 :: (a -> a -> a) -> Flip * * p a a -> a # toList :: Flip * * p a a -> [a] # null :: Flip * * p a a -> Bool # length :: Flip * * p a a -> Int # elem :: Eq a => a -> Flip * * p a a -> Bool # maximum :: Ord a => Flip * * p a a -> a # minimum :: Ord a => Flip * * p a a -> a # sum :: Num a => Flip * * p a a -> a # product :: Num a => Flip * * p a a -> a #
Bitraversable p => Traversable (Flip * * p a)
Methods traverse :: Applicative f => (a -> f b) -> Flip * * p a a -> f (Flip * * p a b) # sequenceA :: Applicative f => Flip * * p a (f a) -> f (Flip * * p a a) # mapM :: Monad m => (a -> m b) -> Flip * * p a a -> m (Flip * * p a b) # sequence :: Monad m => Flip * * p a (m a) -> m (Flip * * p a a) #
Eq (p b a) => Eq (Flip k k1 p a b)
Methods (==) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (/=) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool #
Ord (p b a) => Ord (Flip k k1 p a b)
Methods compare :: Flip k k1 p a b -> Flip k k1 p a b -> Ordering # (<) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (<=) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (>) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (>=) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # max :: Flip k k1 p a b -> Flip k k1 p a b -> Flip k k1 p a b # min :: Flip k k1 p a b -> Flip k k1 p a b -> Flip k k1 p a b #
Read (p b a) => Read (Flip k k1 p a b)
Methods readsPrec :: Int -> ReadS (Flip k k1 p a b) # readList :: ReadS [Flip k k1 p a b] # readPrec :: ReadPrec (Flip k k1 p a b) # readListPrec :: ReadPrec [Flip k k1 p a b] #
Show (p b a) => Show (Flip k k1 p a b)
Methods showsPrec :: Int -> Flip k k1 p a b -> ShowS # show :: Flip k k1 p a b -> String # showList :: [Flip k k1 p a b] -> ShowS #
Generic (Flip k k1 p a b)
Associated Types type Rep (Flip k k1 p a b) :: * -> * # Methods from :: Flip k k1 p a b -> Rep (Flip k k1 p a b) x # to :: Rep (Flip k k1 p a b) x -> Flip k k1 p a b #
type Rep (Flip k k1 p a b)
type Rep (Flip k k1 p a b) = D1 (MetaData "Flip" "Data.Bifunctor.Flip" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Flip" PrefixI True) (S1 (MetaSel (Just Symbol "runFlip") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p b a))))

class BifunctorFunctor k k1 k2 k3 t where #

Minimal complete definition

bifmap

Methods

bifmap :: (:->) k2 k3 p q -> (:->) k k1 (t p) (t q) #

Instances

BifunctorFunctor k1 k k k1 (Flip k k1)
Methods bifmap :: (k2 :-> k3) p q -> (Flip k k1 :-> k1) (t p) (t q) #
Functor f => BifunctorFunctor k k1 k k1 (Tannen k k1 * f)
Methods bifmap :: (k2 :-> k3) p q -> (Tannen k k1 * f :-> k1) (t p) (t q) #

class BifunctorFunctor k k1 k k1 t => BifunctorMonad k k1 t where #

Minimal complete definition

bireturn, (bibind | bijoin)

Methods

bireturn :: p a b -> t p a b #

bibind :: (:->) k k1 p (t q) -> (:->) k k1 (t p) (t q) #

bijoin :: t (t p) a b -> t p a b #

Instances

(Functor f, Monad f) => BifunctorMonad k k1 (Tannen k k1 * f)
Methods bireturn :: p a b -> t p a b # bibind :: (Tannen k k1 * f :-> k1) p (t q) -> (Tannen k k1 * f :-> k1) (t p) (t q) # bijoin :: t (t p) a b -> t p a b #

biliftM :: BifunctorMonad k k1 t => (:->) k k1 p q -> (:->) k k1 (t p) (t q) #

class BifunctorFunctor k k1 k k1 t => BifunctorComonad k k1 t where #

Minimal complete definition

biextract, (biextend | biduplicate)

Methods

biextract :: t p a b -> p a b #

biextend :: (:->) k k1 (t p) q -> (:->) k k1 (t p) (t q) #

biduplicate :: t p a b -> t (t p) a b #

Instances

Comonad f => BifunctorComonad k k1 (Tannen k k1 * f)
Methods biextract :: t p a b -> p a b # biextend :: (Tannen k k1 * f :-> k1) (t p) q -> (Tannen k k1 * f :-> k1) (t p) (t q) # biduplicate :: t p a b -> t (t p) a b #

biliftW :: BifunctorComonad k k1 t => (:->) k k1 p q -> (:->) k k1 (t p) (t q) #

newtype Join k p a :: forall k. (k -> k -> *) -> k -> * #

Make a Functor over both arguments of a Bifunctor.

Constructors

Join
Fields runJoin :: p a a

Instances

Bifunctor p => Functor (Join * p)
Methods fmap :: (a -> b) -> Join * p a -> Join * p b # (<$) :: a -> Join * p b -> Join * p a #
Biapplicative p => Applicative (Join * p)
Methods pure :: a -> Join * p a # (<>) :: Join p (a -> b) -> Join * p a -> Join * p b # (>) :: Join p a -> Join * p b -> Join * p b # (<) :: Join p a -> Join * p b -> Join * p a #
Bifoldable p => Foldable (Join * p)
Methods fold :: Monoid m => Join * p m -> m # foldMap :: Monoid m => (a -> m) -> Join * p a -> m # foldr :: (a -> b -> b) -> b -> Join * p a -> b # foldr' :: (a -> b -> b) -> b -> Join * p a -> b # foldl :: (b -> a -> b) -> b -> Join * p a -> b # foldl' :: (b -> a -> b) -> b -> Join * p a -> b # foldr1 :: (a -> a -> a) -> Join * p a -> a # foldl1 :: (a -> a -> a) -> Join * p a -> a # toList :: Join * p a -> [a] # null :: Join * p a -> Bool # length :: Join * p a -> Int # elem :: Eq a => a -> Join * p a -> Bool # maximum :: Ord a => Join * p a -> a # minimum :: Ord a => Join * p a -> a # sum :: Num a => Join * p a -> a # product :: Num a => Join * p a -> a #
Bitraversable p => Traversable (Join * p)
Methods traverse :: Applicative f => (a -> f b) -> Join * p a -> f (Join * p b) # sequenceA :: Applicative f => Join * p (f a) -> f (Join * p a) # mapM :: Monad m => (a -> m b) -> Join * p a -> m (Join * p b) # sequence :: Monad m => Join * p (m a) -> m (Join * p a) #
Eq (p a a) => Eq (Join k p a)
Methods (==) :: Join k p a -> Join k p a -> Bool # (/=) :: Join k p a -> Join k p a -> Bool #
Ord (p a a) => Ord (Join k p a)
Methods compare :: Join k p a -> Join k p a -> Ordering # (<) :: Join k p a -> Join k p a -> Bool # (<=) :: Join k p a -> Join k p a -> Bool # (>) :: Join k p a -> Join k p a -> Bool # (>=) :: Join k p a -> Join k p a -> Bool # max :: Join k p a -> Join k p a -> Join k p a # min :: Join k p a -> Join k p a -> Join k p a #
Read (p a a) => Read (Join k p a)
Methods readsPrec :: Int -> ReadS (Join k p a) # readList :: ReadS [Join k p a] # readPrec :: ReadPrec (Join k p a) # readListPrec :: ReadPrec [Join k p a] #
Show (p a a) => Show (Join k p a)
Methods showsPrec :: Int -> Join k p a -> ShowS # show :: Join k p a -> String # showList :: [Join k p a] -> ShowS #
Generic (Join k p a)
Associated Types type Rep (Join k p a) :: * -> * # Methods from :: Join k p a -> Rep (Join k p a) x # to :: Rep (Join k p a) x -> Join k p a #
type Rep (Join k p a)
type Rep (Join k p a) = D1 (MetaData "Join" "Data.Bifunctor.Join" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Join" PrefixI True) (S1 (MetaSel (Just Symbol "runJoin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p a a))))

newtype Joker k k1 g a b :: forall k k1. (k1 -> *) -> k -> k1 -> * #

Make a Functor over the second argument of a Bifunctor.

Mnemonic: Clowns to the left (parameter of the Bifunctor), jokers to the right.

Constructors

Joker
Fields runJoker :: g b

Instances

Functor g => Bifunctor (Joker * * g)
Methods bimap :: (a -> b) -> (c -> d) -> Joker * * g a c -> Joker * * g b d # first :: (a -> b) -> Joker * * g a c -> Joker * * g b c # second :: (b -> c) -> Joker * * g a b -> Joker * * g a c #
Applicative g => Biapplicative (Joker * * g)
Methods bipure :: a -> b -> Joker * * g a b # (<<>>) :: Joker * g (a -> b) (c -> d) -> Joker * * g a c -> Joker * * g b d # (>>) :: Joker * g a b -> Joker * * g c d -> Joker * * g c d # (<<) :: Joker * g a b -> Joker * * g c d -> Joker * * g a b #
Traversable g => Bitraversable (Joker * * g)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Joker * * g a b -> f (Joker * * g c d) #
Foldable g => Bifoldable (Joker * * g)
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 #
Functor g => Functor (Joker k * g a)
Methods fmap :: (a -> b) -> Joker k * g a a -> Joker k * g a b # (<$) :: a -> Joker k * g a b -> Joker k * g a a #
Foldable g => Foldable (Joker k * g a)
Methods fold :: Monoid m => Joker k * g a m -> m # foldMap :: Monoid m => (a -> m) -> Joker k * g a a -> m # foldr :: (a -> b -> b) -> b -> Joker k * g a a -> b # foldr' :: (a -> b -> b) -> b -> Joker k * g a a -> b # foldl :: (b -> a -> b) -> b -> Joker k * g a a -> b # foldl' :: (b -> a -> b) -> b -> Joker k * g a a -> b # foldr1 :: (a -> a -> a) -> Joker k * g a a -> a # foldl1 :: (a -> a -> a) -> Joker k * g a a -> a # toList :: Joker k * g a a -> [a] # null :: Joker k * g a a -> Bool # length :: Joker k * g a a -> Int # elem :: Eq a => a -> Joker k * g a a -> Bool # maximum :: Ord a => Joker k * g a a -> a # minimum :: Ord a => Joker k * g a a -> a # sum :: Num a => Joker k * g a a -> a # product :: Num a => Joker k * g a a -> a #
Traversable g => Traversable (Joker k * g a)
Methods traverse :: Applicative f => (a -> f b) -> Joker k * g a a -> f (Joker k * g a b) # sequenceA :: Applicative f => Joker k * g a (f a) -> f (Joker k * g a a) # mapM :: Monad m => (a -> m b) -> Joker k * g a a -> m (Joker k * g a b) # sequence :: Monad m => Joker k * g a (m a) -> m (Joker k * g a a) #
Generic1 (Joker k * g a)
Associated Types type Rep1 (Joker k * g a :: * -> ) :: -> * # Methods from1 :: Joker k * g a a -> Rep1 (Joker k * g a) a # to1 :: Rep1 (Joker k * g a) a -> Joker k * g a a #
Eq (g b) => Eq (Joker k1 k g a b)
Methods (==) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool # (/=) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool #
Ord (g b) => Ord (Joker k1 k g a b)
Methods compare :: Joker k1 k g a b -> Joker k1 k g a b -> Ordering # (<) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool # (<=) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool # (>) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool # (>=) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool # max :: Joker k1 k g a b -> Joker k1 k g a b -> Joker k1 k g a b # min :: Joker k1 k g a b -> Joker k1 k g a b -> Joker k1 k g a b #
Read (g b) => Read (Joker k1 k g a b)
Methods readsPrec :: Int -> ReadS (Joker k1 k g a b) # readList :: ReadS [Joker k1 k g a b] # readPrec :: ReadPrec (Joker k1 k g a b) # readListPrec :: ReadPrec [Joker k1 k g a b] #
Show (g b) => Show (Joker k1 k g a b)
Methods showsPrec :: Int -> Joker k1 k g a b -> ShowS # show :: Joker k1 k g a b -> String # showList :: [Joker k1 k g a b] -> ShowS #
Generic (Joker k1 k g a b)
Associated Types type Rep (Joker k1 k g a b) :: * -> * # Methods from :: Joker k1 k g a b -> Rep (Joker k1 k g a b) x # to :: Rep (Joker k1 k g a b) x -> Joker k1 k g a b #
type Rep1 (Joker k * g a)
type Rep1 (Joker k * g a) = D1 (MetaData "Joker" "Data.Bifunctor.Joker" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Joker" PrefixI True) (S1 (MetaSel (Just Symbol "runJoker") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g)))
type Rep (Joker k1 k g a b)
type Rep (Joker k1 k g a b) = D1 (MetaData "Joker" "Data.Bifunctor.Joker" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Joker" PrefixI True) (S1 (MetaSel (Just Symbol "runJoker") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g b))))

newtype Tannen k k1 k2 f p a b :: forall k k1 k2. (k2 -> *) -> (k1 -> k -> k2) -> k1 -> k -> * #

Compose a Functor on the outside of a Bifunctor.

Constructors

Tannen
Fields runTannen :: f (p a b)

Instances

Functor f => BifunctorFunctor k k1 k k1 (Tannen k k1 * f)
Methods bifmap :: (k2 :-> k3) p q -> (Tannen k k1 * f :-> k1) (t p) (t q) #
(Functor f, Monad f) => BifunctorMonad k k1 (Tannen k k1 * f)
Methods bireturn :: p a b -> t p a b # bibind :: (Tannen k k1 * f :-> k1) p (t q) -> (Tannen k k1 * f :-> k1) (t p) (t q) # bijoin :: t (t p) a b -> t p a b #
Comonad f => BifunctorComonad k k1 (Tannen k k1 * f)
Methods biextract :: t p a b -> p a b # biextend :: (Tannen k k1 * f :-> k1) (t p) q -> (Tannen k k1 * f :-> k1) (t p) (t q) # biduplicate :: t p a b -> t (t p) a b #
(Applicative f, Category k p) => Category k (Tannen k k * f p)
Methods id :: cat a a # (.) :: cat b c -> cat a b -> cat a c #
(Functor f, Bifunctor p) => Bifunctor (Tannen * * * f p)
Methods bimap :: (a -> b) -> (c -> d) -> Tannen * * * f p a c -> Tannen * * * f p b d # first :: (a -> b) -> Tannen * * * f p a c -> Tannen * * * f p b c # second :: (b -> c) -> Tannen * * * f p a b -> Tannen * * * f p a c #
(Applicative f, Arrow p) => Arrow (Tannen * * * f p)
Methods arr :: (b -> c) -> Tannen * * * f p b c # first :: Tannen * * * f p b c -> Tannen * * * f p (b, d) (c, d) # second :: Tannen * * * f p b c -> Tannen * * * f p (d, b) (d, c) # (**) :: Tannen * * f p b c -> Tannen * * * f p b' c' -> Tannen * * * f p (b, b') (c, c') # (&&&) :: Tannen * * * f p b c -> Tannen * * * f p b c' -> Tannen * * * f p b (c, c') #
(Applicative f, ArrowZero p) => ArrowZero (Tannen * * * f p)
Methods zeroArrow :: Tannen * * * f p b c #
(Applicative f, ArrowPlus p) => ArrowPlus (Tannen * * * f p)
Methods (<+>) :: Tannen * * * f p b c -> Tannen * * * f p b c -> Tannen * * * f p b c #
(Applicative f, ArrowChoice p) => ArrowChoice (Tannen * * * f p)
Methods left :: Tannen * * * f p b c -> Tannen * * * f p (Either b d) (Either c d) # right :: Tannen * * * f p b c -> Tannen * * * f p (Either d b) (Either d c) # (+++) :: Tannen * * * f p b c -> Tannen * * * f p b' c' -> Tannen * * * f p (Either b b') (Either c c') # (\|\|\|) :: Tannen * * * f p b d -> Tannen * * * f p c d -> Tannen * * * f p (Either b c) d #
(Applicative f, ArrowLoop p) => ArrowLoop (Tannen * * * f p)
Methods loop :: Tannen * * * f p (b, d) (c, d) -> Tannen * * * f p b c #
(Applicative f, Biapplicative p) => Biapplicative (Tannen * * * f p)
Methods bipure :: a -> b -> Tannen * * * f p a b # (<<>>) :: Tannen * * f p (a -> b) (c -> d) -> Tannen * * * f p a c -> Tannen * * * f p b d # (>>) :: Tannen * * f p a b -> Tannen * * * f p c d -> Tannen * * * f p c d # (<<) :: Tannen * * f p a b -> Tannen * * * f p c d -> Tannen * * * f p a b #
(Traversable f, Bitraversable p) => Bitraversable (Tannen * * * f p)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Tannen * * * f p a b -> f (Tannen * * * f p c d) #
(Foldable f, Bifoldable p) => Bifoldable (Tannen * * * f p)
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 #
(Functor f, Bifunctor p) => Functor (Tannen * * * f p a)
Methods fmap :: (a -> b) -> Tannen * * * f p a a -> Tannen * * * f p a b # (<$) :: a -> Tannen * * * f p a b -> Tannen * * * f p a a #
(Foldable f, Bifoldable p) => Foldable (Tannen * * * f p a)
Methods fold :: Monoid m => Tannen * * * f p a m -> m # foldMap :: Monoid m => (a -> m) -> Tannen * * * f p a a -> m # foldr :: (a -> b -> b) -> b -> Tannen * * * f p a a -> b # foldr' :: (a -> b -> b) -> b -> Tannen * * * f p a a -> b # foldl :: (b -> a -> b) -> b -> Tannen * * * f p a a -> b # foldl' :: (b -> a -> b) -> b -> Tannen * * * f p a a -> b # foldr1 :: (a -> a -> a) -> Tannen * * * f p a a -> a # foldl1 :: (a -> a -> a) -> Tannen * * * f p a a -> a # toList :: Tannen * * * f p a a -> [a] # null :: Tannen * * * f p a a -> Bool # length :: Tannen * * * f p a a -> Int # elem :: Eq a => a -> Tannen * * * f p a a -> Bool # maximum :: Ord a => Tannen * * * f p a a -> a # minimum :: Ord a => Tannen * * * f p a a -> a # sum :: Num a => Tannen * * * f p a a -> a # product :: Num a => Tannen * * * f p a a -> a #
(Traversable f, Bitraversable p) => Traversable (Tannen * * * f p a)
Methods traverse :: Applicative f => (a -> f b) -> Tannen * * * f p a a -> f (Tannen * * * f p a b) # sequenceA :: Applicative f => Tannen * * * f p a (f a) -> f (Tannen * * * f p a a) # mapM :: Monad m => (a -> m b) -> Tannen * * * f p a a -> m (Tannen * * * f p a b) # sequence :: Monad m => Tannen * * * f p a (m a) -> m (Tannen * * * f p a a) #
Functor f => Generic1 (Tannen * k * f p a)
Associated Types type Rep1 (Tannen * k * f p a :: * -> ) :: -> * # Methods from1 :: Tannen * k * f p a a -> Rep1 (Tannen * k * f p a) a # to1 :: Rep1 (Tannen * k * f p a) a -> Tannen * k * f p a a #
Eq (f (p a b)) => Eq (Tannen k2 k1 k f p a b)
Methods (==) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool # (/=) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool #
Ord (f (p a b)) => Ord (Tannen k2 k1 k f p a b)
Methods compare :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Ordering # (<) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool # (<=) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool # (>) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool # (>=) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool # max :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b # min :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b #
Read (f (p a b)) => Read (Tannen k2 k1 k f p a b)
Methods readsPrec :: Int -> ReadS (Tannen k2 k1 k f p a b) # readList :: ReadS [Tannen k2 k1 k f p a b] # readPrec :: ReadPrec (Tannen k2 k1 k f p a b) # readListPrec :: ReadPrec [Tannen k2 k1 k f p a b] #
Show (f (p a b)) => Show (Tannen k2 k1 k f p a b)
Methods showsPrec :: Int -> Tannen k2 k1 k f p a b -> ShowS # show :: Tannen k2 k1 k f p a b -> String # showList :: [Tannen k2 k1 k f p a b] -> ShowS #
Generic (Tannen k2 k1 k f p a b)
Associated Types type Rep (Tannen k2 k1 k f p a b) :: * -> * # Methods from :: Tannen k2 k1 k f p a b -> Rep (Tannen k2 k1 k f p a b) x # to :: Rep (Tannen k2 k1 k f p a b) x -> Tannen k2 k1 k f p a b #
type Rep1 (Tannen * k * f p a)
type Rep1 (Tannen * k * f p a) = D1 (MetaData "Tannen" "Data.Bifunctor.Tannen" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Tannen" PrefixI True) (S1 (MetaSel (Just Symbol "runTannen") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) f (Rec1 (p a)))))
type Rep (Tannen k2 k1 k f p a b)
type Rep (Tannen k2 k1 k f p a b) = D1 (MetaData "Tannen" "Data.Bifunctor.Tannen" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "Tannen" PrefixI True) (S1 (MetaSel (Just Symbol "runTannen") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f (p a b)))))

newtype WrappedBifunctor k k1 p a b :: forall k k1. (k1 -> k -> *) -> k1 -> k -> * #

Make a Functor over the second argument of a Bifunctor.

Constructors

WrapBifunctor
Fields unwrapBifunctor :: p a b

Instances

Bifunctor p => Bifunctor (WrappedBifunctor * * p)
Methods bimap :: (a -> b) -> (c -> d) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b d # first :: (a -> b) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b c # second :: (b -> c) -> WrappedBifunctor * * p a b -> WrappedBifunctor * * p a c #
Biapplicative p => Biapplicative (WrappedBifunctor * * p)
Methods bipure :: a -> b -> WrappedBifunctor * * p a b # (<<>>) :: WrappedBifunctor * p (a -> b) (c -> d) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b d # (>>) :: WrappedBifunctor * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p c d # (<<) :: WrappedBifunctor * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p a b #
Bitraversable p => Bitraversable (WrappedBifunctor * * p)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> WrappedBifunctor * * p a b -> f (WrappedBifunctor * * p c d) #
Bifoldable p => Bifoldable (WrappedBifunctor * * p)
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 #
Bifunctor p => Functor (WrappedBifunctor * * p a)
Methods fmap :: (a -> b) -> WrappedBifunctor * * p a a -> WrappedBifunctor * * p a b # (<$) :: a -> WrappedBifunctor * * p a b -> WrappedBifunctor * * p a a #
Bifoldable p => Foldable (WrappedBifunctor * * p a)
Methods fold :: Monoid m => WrappedBifunctor * * p a m -> m # foldMap :: Monoid m => (a -> m) -> WrappedBifunctor * * p a a -> m # foldr :: (a -> b -> b) -> b -> WrappedBifunctor * * p a a -> b # foldr' :: (a -> b -> b) -> b -> WrappedBifunctor * * p a a -> b # foldl :: (b -> a -> b) -> b -> WrappedBifunctor * * p a a -> b # foldl' :: (b -> a -> b) -> b -> WrappedBifunctor * * p a a -> b # foldr1 :: (a -> a -> a) -> WrappedBifunctor * * p a a -> a # foldl1 :: (a -> a -> a) -> WrappedBifunctor * * p a a -> a # toList :: WrappedBifunctor * * p a a -> [a] # null :: WrappedBifunctor * * p a a -> Bool # length :: WrappedBifunctor * * p a a -> Int # elem :: Eq a => a -> WrappedBifunctor * * p a a -> Bool # maximum :: Ord a => WrappedBifunctor * * p a a -> a # minimum :: Ord a => WrappedBifunctor * * p a a -> a # sum :: Num a => WrappedBifunctor * * p a a -> a # product :: Num a => WrappedBifunctor * * p a a -> a #
Bitraversable p => Traversable (WrappedBifunctor * * p a)
Methods traverse :: Applicative f => (a -> f b) -> WrappedBifunctor * * p a a -> f (WrappedBifunctor * * p a b) # sequenceA :: Applicative f => WrappedBifunctor * * p a (f a) -> f (WrappedBifunctor * * p a a) # mapM :: Monad m => (a -> m b) -> WrappedBifunctor * * p a a -> m (WrappedBifunctor * * p a b) # sequence :: Monad m => WrappedBifunctor * * p a (m a) -> m (WrappedBifunctor * * p a a) #
Generic1 (WrappedBifunctor * k p a)
Associated Types type Rep1 (WrappedBifunctor * k p a :: * -> ) :: -> * # Methods from1 :: WrappedBifunctor * k p a a -> Rep1 (WrappedBifunctor * k p a) a # to1 :: Rep1 (WrappedBifunctor * k p a) a -> WrappedBifunctor * k p a a #
Eq (p a b) => Eq (WrappedBifunctor k1 k p a b)
Methods (==) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool # (/=) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool #
Ord (p a b) => Ord (WrappedBifunctor k1 k p a b)
Methods compare :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Ordering # (<) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool # (<=) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool # (>) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool # (>=) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool # max :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b # min :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b #
Read (p a b) => Read (WrappedBifunctor k1 k p a b)
Methods readsPrec :: Int -> ReadS (WrappedBifunctor k1 k p a b) # readList :: ReadS [WrappedBifunctor k1 k p a b] # readPrec :: ReadPrec (WrappedBifunctor k1 k p a b) # readListPrec :: ReadPrec [WrappedBifunctor k1 k p a b] #
Show (p a b) => Show (WrappedBifunctor k1 k p a b)
Methods showsPrec :: Int -> WrappedBifunctor k1 k p a b -> ShowS # show :: WrappedBifunctor k1 k p a b -> String # showList :: [WrappedBifunctor k1 k p a b] -> ShowS #
Generic (WrappedBifunctor k1 k p a b)
Associated Types type Rep (WrappedBifunctor k1 k p a b) :: * -> * # Methods from :: WrappedBifunctor k1 k p a b -> Rep (WrappedBifunctor k1 k p a b) x # to :: Rep (WrappedBifunctor k1 k p a b) x -> WrappedBifunctor k1 k p a b #
type Rep1 (WrappedBifunctor * k p a)
type Rep1 (WrappedBifunctor * k p a) = D1 (MetaData "WrappedBifunctor" "Data.Bifunctor.Wrapped" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "WrapBifunctor" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapBifunctor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (p a))))
type Rep (WrappedBifunctor k1 k p a b)
type Rep (WrappedBifunctor k1 k p a b) = D1 (MetaData "WrappedBifunctor" "Data.Bifunctor.Wrapped" "bifunctors-5.4.2-F4sCnFKuRGj7fkepfA4lkE" True) (C1 (MetaCons "WrapBifunctor" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapBifunctor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p a b))))

class (Bifunctor t, Bifoldable t) => Bitraversable t where #

Bitraversable identifies bifunctorial data structures whose elements can be traversed in order, performing Applicative or Monad actions at each element, and collecting a result structure with the same shape.

As opposed to Traversable data structures, which have one variety of element on which an action can be performed, Bitraversable data structures have two such varieties of elements.

A definition of bitraverse must satisfy the following laws:

naturality: bitraverse (t . f) (t . g) ≡ t . bitraverse f g for every applicative transformation t
identity: bitraverse Identity Identity ≡ Identity
composition: Compose . fmap (bitraverse g1 g2) . bitraverse f1 f2 ≡ traverse (Compose . fmap g1 . f1) (Compose . fmap g2 . f2)

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations:

t (pure x) = pure x
t (f <*> x) = t f <*> t x

and the identity functor Identity and composition functors Compose are defined as

newtype Identity a = Identity { runIdentity :: a }

instance Functor Identity where
  fmap f (Identity x) = Identity (f x)

instance Applicative Identity where
  pure = Identity
  Identity f <*> Identity x = Identity (f x)

newtype Compose f g a = Compose (f (g a))

instance (Functor f, Functor g) => Functor (Compose f g) where
  fmap f (Compose x) = Compose (fmap (fmap f) x)

instance (Applicative f, Applicative g) => Applicative (Compose f g) where
  pure = Compose . pure . pure
  Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

Some simple examples are Either and '(,)':

instance Bitraversable Either where
  bitraverse f _ (Left x) = Left <$> f x
  bitraverse _ g (Right y) = Right <$> g y

instance Bitraversable (,) where
  bitraverse f g (x, y) = (,) <$> f x <*> g y

Bitraversable relates to its superclasses in the following ways:

bimap f g ≡ runIdentity . bitraverse (Identity . f) (Identity . g)
bifoldMap f g = getConst . bitraverse (Const . f) (Const . g)

These are available as bimapDefault and bifoldMapDefault respectively.

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d) #

Evaluates the relevant functions at each element in the structure, running the action, and builds a new structure with the same shape, using the elements produced from sequencing the actions.

bitraverse f g ≡ bisequenceA . bimap f g

For a version that ignores the results, see bitraverse_.

Instances

Bitraversable Either
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) #
Bitraversable (,)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (a, b) -> f (c, d) #
Bitraversable Arg
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Arg a b -> f (Arg c d) #
Bitraversable (K1 i)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> K1 i a b -> f (K1 i c d) #
Bitraversable ((,,) x)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, a, b) -> f (x, c, d) #
Bitraversable (Const *)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const * a b -> f (Const * c d) #
Bitraversable (Tagged *)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Tagged * a b -> f (Tagged * c d) #
Bitraversable (Constant *)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Constant * a b -> f (Constant * c d) #
Bitraversable ((,,,) x y)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, a, b) -> f (x, y, c, d) #
Bitraversable ((,,,,) x y z)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, z, a, b) -> f (x, y, z, c, d) #
Bitraversable p => Bitraversable (WrappedBifunctor * * p)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> WrappedBifunctor * * p a b -> f (WrappedBifunctor * * p c d) #
Traversable g => Bitraversable (Joker * * g)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Joker * * g a b -> f (Joker * * g c d) #
Bitraversable p => Bitraversable (Flip * * p)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Flip * * p a b -> f (Flip * * p c d) #
Traversable f => Bitraversable (Clown * * f)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Clown * * f a b -> f (Clown * * f c d) #
Bitraversable ((,,,,,) x y z w)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, z, w, a, b) -> f (x, y, z, w, c, d) #
Bitraversable ((,,,,,,) x y z w v)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> (x, y, z, w, v, a, b) -> f (x, y, z, w, v, c, d) #
(Traversable f, Bitraversable p) => Bitraversable (Tannen * * * f p)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Tannen * * * f p a b -> f (Tannen * * * f p c d) #
(Bitraversable p, Traversable f, Traversable g) => Bitraversable (Biff * * * * p f g)
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Biff * * * * p f g a b -> f (Biff * * * * p f g c d) #

bisequenceA :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b) #

Sequences all the actions in a structure, building a new structure with the same shape using the results of the actions. For a version that ignores the results, see bisequenceA_.

bisequenceA ≡ bitraverse id id

bisequence :: (Bitraversable t, Monad m) => t (m a) (m b) -> m (t a b) #

As bisequenceA, but uses evidence that m is a Monad rather than an Applicative. For a version that ignores the results, see bisequence_.

bisequence ≡ bimapM id id
bisequence ≡ unwrapMonad . bisequenceA . bimap WrapMonad WrapMonad

bimapM :: (Bitraversable t, Monad m) => (a -> m c) -> (b -> m d) -> t a b -> m (t c d) #

As bitraverse, but uses evidence that m is a Monad rather than an Applicative. For a version that ignores the results, see bimapM_.

bimapM f g ≡ bisequence . bimap f g
bimapM f g ≡ unwrapMonad . bitraverse (WrapMonad . f) (WrapMonad . g)

bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d) #

bifor is bitraverse with the structure as the first argument. For a version that ignores the results, see bifor_.

biforM :: (Bitraversable t, Monad m) => t a b -> (a -> m c) -> (b -> m d) -> m (t c d) #

biforM is bimapM with the structure as the first argument. For a version that ignores the results, see biforM_.

bimapAccumL :: Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e) #

The bimapAccumL function behaves like a combination of bimap and bifoldl; it traverses a structure from left to right, threading a state of type a and using the given actions to compute new elements for the structure.

bimapAccumR :: Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e) #

The bimapAccumR function behaves like a combination of bimap and bifoldl; it traverses a structure from right to left, threading a state of type a and using the given actions to compute new elements for the structure.

bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d #

A default definition of bimap in terms of the Bitraversable operations.

bimapDefault f g ≡
     runIdentity . bitraverse (Identity . f) (Identity . g)

bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m #

A default definition of bifoldMap in terms of the Bitraversable operations.

bifoldMapDefault f g ≡
    getConst . bitraverse (Const . f) (Const . g)