Modulebarbies-2.1.1.0Haskell2010

Barbies.Bi

1 type
10 values

Packagebarbies-2.1.1.0
Exports11
LanguageHaskell2010
LicenceBSD-3-Clause
SourceBi.hs

Functor

2 declarations

A bifunctor is simultaneously a FunctorT and a FunctorB.

valuebtmap

:: (FunctorB (b f), FunctorT b)
=> forall (a :: k1). f a -> f' a
-> forall (a :: k2). g a -> g' a
-> b f g
-> b f' g'

Map over both arguments at the same time.

valuebtmap1

:: (FunctorB (b f), FunctorT b)
=> forall (a :: k). f a -> g a
-> b f f
-> b g g

A version of btmap specialized to a single argument.

Traversable

5 declarations

A traversable bifunctor is simultaneously a TraversableT and a TraversableB.

valuebttraverse

:: (TraversableB (b f), TraversableT b, Monad t)
=> forall (a :: k1). f a -> t (f' a)
-> forall (a :: k2). g a -> t (g' a)
-> b f g
-> t (b f' g')

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

valuebttraverse1

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

A version of bttraverse specialized to a single argument.

valuebtfor1

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

bttraverse1 with the arguments flipped.

valuebttraverse_

:: (TraversableB (b f), TraversableT b, Monad e)
=> forall (a :: k1). f a -> e c
-> forall (a :: k2). g a -> e d
-> b f g
-> e ()

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

valuebtfoldMap

:: (TraversableB (b f), TraversableT b, Monoid m)
=> forall (a :: k1). f a -> m
-> forall (a :: k2). g a -> m
-> b f g
-> m

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

Applicative

3 declarations

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.

valuebtpure

:: (ApplicativeB (b Unit), FunctorT b)
=> forall (a :: k1 -> Type). f a
-> forall (a :: k2). g a
-> b f g

Conceptually, this is like simultaneously using bpure and tpure.

valuebtpure1

:: (ApplicativeB (b Unit), FunctorT b)
=> forall (a :: k -> Type). f a
-> b f f

A version of btpure specialized to a single argument.

valuebtprod

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

Simultaneous product on both arguments.

Wrappers

1 declaration

newtypenewtype Flip (b :: k -> k1 -> Type) (l :: k1) (r :: k)

Convert a FunctorB into a FunctorT and vice-versa.

Constructors

Flip
- runFlip :: b r l

Instances12ApplicativeT, FunctorT, TraversableT, DistributiveT, ApplicativeB, DistributiveB, …

(forall (f :: k'). ApplicativeB (b f)) => ApplicativeT (Flip b)Defined in barbies-2.1.1.0 · Barbies.Bi
(forall (f :: k'). FunctorB (b f)) => FunctorT (Flip b)Defined in barbies-2.1.1.0 · Barbies.Bi
(forall (f :: k'). TraversableB (b f)) => TraversableT (Flip b)Defined in barbies-2.1.1.0 · Barbies.Bi
(forall (f :: i). DistributiveB (b f)) => DistributiveT (Flip b)Defined in barbies-2.1.1.0 · Barbies.Bi
ApplicativeT b => ApplicativeB (Flip b f)Defined in barbies-2.1.1.0 · Barbies.Bi
DistributiveT b => DistributiveB (Flip b f)Defined in barbies-2.1.1.0 · Barbies.Bi
FunctorT b => FunctorB (Flip b f)Defined in barbies-2.1.1.0 · Barbies.Bi
TraversableT b => TraversableB (Flip b f)Defined in barbies-2.1.1.0 · Barbies.Bi
Eq (b r l) => Eq (Flip b l r)Defined in barbies-2.1.1.0 · Barbies.Bi
Ord (b r l) => Ord (Flip b l r)Defined in barbies-2.1.1.0 · Barbies.Bi
Read (b r l) => Read (Flip b l r)Defined in barbies-2.1.1.0 · Barbies.Bi
Show (b r l) => Show (Flip b l r)Defined in barbies-2.1.1.0 · Barbies.Bi