bifunctors-5.4.1: Bifunctors

Data.Bitraversable

Description

Synopsis

# Documentation

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

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 traverse 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) Source #

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

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

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

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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) Source #

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 Source #

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

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

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