Safe Haskell	None
Language	Haskell2010

Barbies.Bi

Contents

Functor
Traversable
Applicative
Wrappers

Synopsis

btmap :: ( FunctorB (b f), FunctorT b) => ( forall a. f a -> f' a) -> ( forall a. g a -> g' a) -> b f g -> b f' g'
btmap1 :: ( FunctorB (b f), FunctorT b) => ( forall a. f a -> g a) -> b f f -> b g g
bttraverse :: ( TraversableB (b f), TraversableT b, Monad t) => ( forall a. f a -> t (f' a)) -> ( forall a. g a -> t (g' a)) -> b f g -> t (b f' g')
bttraverse1 :: ( TraversableB (b f), TraversableT b, Monad t) => ( forall a. f a -> t (g a)) -> b f f -> t (b g g)
bttraverse_ :: ( TraversableB (b f), TraversableT b, Monad e) => ( forall a. f a -> e c) -> ( forall a. g a -> e d) -> b f g -> e ()
btfoldMap :: ( TraversableB (b f), TraversableT b, Monoid m) => ( forall a. f a -> m) -> ( forall a. g a -> m) -> b f g -> m
btpure :: ( ApplicativeB (b Unit ), FunctorT b) => ( forall a. f a) -> ( forall a. g a) -> b f g
btpure1 :: ( ApplicativeB (b Unit ), FunctorT b) => ( forall a. f a) -> b f f
btprod :: ( ApplicativeB (b ( Alt ( Product f f'))), FunctorT b, Alternative f, Alternative f') => b f g -> b f' g' -> b (f `Product` f') (g `Product` g')
newtype Flip b l r = Flip {
- runFlip :: b r l
}

Functor

A bifunctor is simultaneously a FunctorT and a FunctorB .

btmap :: ( FunctorB (b f), FunctorT b) => ( forall a. f a -> f' a) -> ( forall a. g a -> g' a) -> b f g -> b f' g' Source #

Map over both arguments at the same time.

btmap1 :: ( FunctorB (b f), FunctorT b) => ( forall a. f a -> g a) -> b f f -> b g g Source #

A version of btmap specialized to a single argument.

Traversable

A traversable bifunctor is simultaneously a TraversableT and a TraversableB .

bttraverse :: ( TraversableB (b f), TraversableT b, Monad t) => ( forall a. f a -> t (f' a)) -> ( forall a. g a -> t (g' a)) -> b f g -> t (b f' g') Source #

Traverse over both arguments, first over f , then over g ..

bttraverse1 :: ( TraversableB (b f), TraversableT b, Monad t) => ( forall a. f a -> t (g a)) -> b f f -> t (b g g) Source #

A version of bttraverse specialized to a single argument.

bttraverse_ :: ( TraversableB (b f), TraversableT b, Monad e) => ( forall a. f a -> e c) -> ( forall a. g a -> e d) -> b f g -> e () Source #

Map each element to an action, evaluate these actions from left to right and ignore the results.

btfoldMap :: ( TraversableB (b f), TraversableT b, Monoid m) => ( forall a. f a -> m) -> ( forall a. g a -> m) -> b f g -> m Source #

Map each element to a monoid, and combine the results.

Applicative

If t is an ApplicativeT , the type of tpure shows that its second argument must be a phantom-type, so there are really no interesting types that are both ApplicativeT and ApplicativeB . However, we can sometimes reconstruct a bi-applicative from an ApplicativeB and a FunctorT .

btpure :: ( ApplicativeB (b Unit ), FunctorT b) => ( forall a. f a) -> ( forall a. g a) -> b f g Source #

Conceptually, this is like simultaneously using bpure and tpure .

btpure1 :: ( ApplicativeB (b Unit ), FunctorT b) => ( forall a. f a) -> b f f Source #

A version of btpure specialized to a single argument.

btprod :: ( ApplicativeB (b ( Alt ( Product f f'))), FunctorT b, Alternative f, Alternative f') => b f g -> b f' g' -> b (f `Product` f') (g `Product` g') Source #

Simultaneous product on both arguments.

Wrappers

newtype Flip b l r Source #

Convert a FunctorB into a FunctorT and vice-versa.

Constructors

Flip
Fields runFlip :: b r l

Instances

Instances details

( forall (f :: k'). FunctorB (b f)) => FunctorT ( Flip b :: (k -> Type ) -> k' -> Type ) Source #
Instance details Defined in Barbies.Bi Methods tmap :: forall f g (x :: k'0). ( forall (a :: k0). f a -> g a) -> Flip b f x -> Flip b g x Source #
( forall (f :: k'). TraversableB (b f)) => TraversableT ( Flip b :: (k -> Type ) -> k' -> Type ) Source #
Instance details Defined in Barbies.Bi Methods ttraverse :: forall e f g (x :: k'0). Applicative e => ( forall (a :: k0). f a -> e (g a)) -> Flip b f x -> e ( Flip b g x) Source #
( forall (f :: k'). ApplicativeB (b f)) => ApplicativeT ( Flip b :: (k -> Type ) -> k' -> Type ) Source #
Instance details Defined in Barbies.Bi Methods tpure :: forall f (x :: k'0). ( forall (a :: k0). f a) -> Flip b f x Source # tprod :: forall (f :: k0 -> Type ) (x :: k'0) (g :: k0 -> Type ). Flip b f x -> Flip b g x -> Flip b ( Product f g) x Source #
( forall (f :: i). DistributiveB (b f)) => DistributiveT ( Flip b :: ( Type -> Type ) -> i -> Type ) Source #
Instance details Defined in Barbies.Bi Methods tdistribute :: forall f (g :: Type -> Type ) (x :: i0). Functor f => f ( Flip b g x) -> Flip b ( Compose f g) x Source #
FunctorT b => FunctorB ( Flip b f :: (k1 -> Type ) -> Type ) Source #
Instance details Defined in Barbies.Bi Methods bmap :: ( forall (a :: k). f0 a -> g a) -> Flip b f f0 -> Flip b f g Source #
TraversableT b => TraversableB ( Flip b f :: (k1 -> Type ) -> Type ) Source #
Instance details Defined in Barbies.Bi Methods btraverse :: Applicative e => ( forall (a :: k). f0 a -> e (g a)) -> Flip b f f0 -> e ( Flip b f g) Source #
DistributiveT b => DistributiveB ( Flip b f :: ( Type -> Type ) -> Type ) Source #
Instance details Defined in Barbies.Bi Methods bdistribute :: forall f0 (g :: k -> Type ). Functor f0 => f0 ( Flip b f g) -> Flip b f ( Compose f0 g) Source #
ApplicativeT b => ApplicativeB ( Flip b f :: (k1 -> Type ) -> Type ) Source #
Instance details Defined in Barbies.Bi Methods bpure :: ( forall (a :: k). f0 a) -> Flip b f f0 Source # bprod :: forall (f0 :: k -> Type ) (g :: k -> Type ). Flip b f f0 -> Flip b f g -> Flip b f ( Product f0 g) Source #
Eq (b r l) => Eq ( Flip b l r) Source #
Instance details Defined in Barbies.Bi Methods (==) :: Flip b l r -> Flip b l r -> Bool Source # (/=) :: Flip b l r -> Flip b l r -> Bool Source #
Ord (b r l) => Ord ( Flip b l r) Source #
Instance details Defined in Barbies.Bi Methods compare :: Flip b l r -> Flip b l r -> Ordering Source # (<) :: Flip b l r -> Flip b l r -> Bool Source # (<=) :: Flip b l r -> Flip b l r -> Bool Source # (>) :: Flip b l r -> Flip b l r -> Bool Source # (>=) :: Flip b l r -> Flip b l r -> Bool Source # max :: Flip b l r -> Flip b l r -> Flip b l r Source # min :: Flip b l r -> Flip b l r -> Flip b l r Source #
Read (b r l) => Read ( Flip b l r) Source #
Instance details Defined in Barbies.Bi Methods readsPrec :: Int -> ReadS ( Flip b l r) Source # readList :: ReadS [ Flip b l r] Source # readPrec :: ReadPrec ( Flip b l r) Source # readListPrec :: ReadPrec [ Flip b l r] Source #
Show (b r l) => Show ( Flip b l r) Source #
Instance details Defined in Barbies.Bi Methods showsPrec :: Int -> Flip b l r -> ShowS Source # show :: Flip b l r -> String Source # showList :: [ Flip b l r] -> ShowS Source #