barbies-2.0.4.0: Classes for working with types that can change clothes.

Safe Haskell | Safe-Inferred
Language | Haskell2010

Data.Functor.Transformer

Contents

- Functor
- Traversable
  - Utility functions
- Distributive
- Applicative
  - Utility functions
- Monad
- Constraints and instance dictionaries
  - Utility functions
- Support for generic derivations

Description

Functors on indexed-types.

Synopsis

- class FunctorT (t :: (k -> Type) -> k' -> Type) where
  - tmap :: (forall a. f a -> g a) -> t f x -> t g x
- class FunctorT t => TraversableT (t :: (k -> Type) -> k' -> Type) where
  - ttraverse :: Applicative e => (forall a. f a -> e (g a)) -> t f x -> e (t g x)
- ttraverse_ :: (TraversableT t, Applicative e) => (forall a. f a -> e c) -> t f x -> e ()
- tfoldMap :: (TraversableT t, Monoid m) => (forall a. f a -> m) -> t f x -> m
- tsequence :: (Applicative e, TraversableT t) => t (Compose e f) x -> e (t f x)
- tsequence' :: (Applicative e, TraversableT t) => t e x -> e (t Identity x)
- class FunctorT t => DistributiveT (t :: (Type -> Type) -> i -> Type) where
  - tdistribute :: Functor f => f (t g x) -> t (Compose f g) x
- tdistribute' :: (DistributiveT t, Functor f) => f (t Identity x) -> t f x
- tcotraverse :: (DistributiveT t, Functor f) => (forall a. f (g a) -> f a) -> f (t g x) -> t f x
- tdecompose :: DistributiveT t => (a -> t Identity x) -> t ((->) a) x
- trecompose :: FunctorT t => t ((->) a) x -> a -> t Identity x
- class FunctorT t => ApplicativeT (t :: (k -> Type) -> k' -> Type) where
  - tpure :: (forall a. f a) -> t f x
  - tprod :: t f x -> t g x -> t (f `Product` g) x
- tzip :: ApplicativeT t => t f x -> t g x -> t (f `Product` g) x
- tunzip :: ApplicativeT t => t (f `Product` g) x -> (t f x, t g x)
- tzipWith :: ApplicativeT t => (forall a. f a -> g a -> h a) -> t f x -> t g x -> t h x
- tzipWith3 :: ApplicativeT t => (forall a. f a -> g a -> h a -> i a) -> t f x -> t g x -> t h x -> t i x
- tzipWith4 :: ApplicativeT t => (forall a. f a -> g a -> h a -> i a -> j a) -> t f x -> t g x -> t h x -> t i x -> t j x
- class FunctorT t => MonadT t where
  - tlift :: f a -> t f a
  - tjoin :: t (t f) a -> t f a
  - tembed :: MonadT t => (forall x. f x -> t g x) -> t f a -> t g a
- class FunctorT t => ConstraintsT (t :: (kl -> Type) -> kr -> Type) where
  - type AllT (c :: k -> Constraint) t :: Constraint
  - taddDicts :: forall c f x. AllT c t => t f x -> t (Dict c `Product` f) x
- type AllTF c f t = AllT (ClassF c f) t
- tmapC :: forall c t f g x. (AllT c t, ConstraintsT t) => (forall a. c a => f a -> g a) -> t f x -> t g x
- ttraverseC :: forall c t f g e x. (TraversableT t, ConstraintsT t, AllT c t, Applicative e) => (forall a. c a => f a -> e (g a)) -> t f x -> e (t g x)
- newtype Rec (p :: Type) a x = Rec {
  - unRec :: K1 R a x
  }

# Functor

class FunctorT (t :: (k -> Type) -> k' -> Type) where Source #

Functor from indexed-types to indexed-types. Instances of `FunctorT` should satisfy the following laws:

    tmap id = id
    tmap f . tmap g = tmap (f . g)

There is a default `tmap` implementation for `Generic` types, so instances can derived automatically.

Minimal complete definition

Nothing

Methods

tmap :: (forall a. f a -> g a) -> t f x -> t g x Source #

default tmap :: forall f g x. CanDeriveFunctorT t f g x => (forall a. f a -> g a) -> t f x -> t g x Source #

#### Instances

Instances details

FunctorT Lift Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> Lift f x -> Lift g x Source #
FunctorT MaybeT Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> MaybeT f x -> MaybeT g x Source #
FunctorT (AccumT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> AccumT w f x -> AccumT w g x Source #
FunctorT (ExceptT e :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> ExceptT e f x -> ExceptT e g x Source #
FunctorT (ReaderT r :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> ReaderT r f x -> ReaderT r g x Source #
FunctorT (StateT s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> StateT s f x -> StateT s g x Source #
FunctorT (StateT s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> StateT s f x -> StateT s g x Source #
FunctorT (WriterT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> WriterT w f x -> WriterT w g x Source #
FunctorT (WriterT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> WriterT w f x -> WriterT w g x Source #
FunctorT (Backwards :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'0). (forall (a :: k). f a -> g a) -> Backwards f x -> Backwards g x Source #
FunctorT (IdentityT :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'0). (forall (a :: k). f a -> g a) -> IdentityT f x -> IdentityT g x Source #
FunctorT (Reverse :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'0). (forall (a :: k). f a -> g a) -> Reverse f x -> Reverse g x Source #
FunctorT (Product f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f0 g (x :: k'0). (forall (a :: k). f0 a -> g a) -> Product f f0 x -> Product f g x Source #
FunctorT (Sum f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f0 g (x :: k'0). (forall (a :: k). f0 a -> g a) -> Sum f f0 x -> Sum f g x Source #
FunctorT (RWST r w s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> RWST r w s f x -> RWST r w s g x Source #
FunctorT (RWST r w s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f g (x :: k'). (forall (a :: k). f a -> g a) -> RWST r w s f x -> RWST r w s g x Source #
(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 #
Functor f => FunctorT (Compose f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.FunctorT Methods tmap :: forall f0 g (x :: k'0). (forall (a :: k). f0 a -> g a) -> Compose f f0 x -> Compose f g x Source #

# Traversable

class FunctorT t => TraversableT (t :: (k -> Type) -> k' -> Type) where Source #

Indexed-functors that can be traversed from left to right. Instances should satisfy the following laws:

     t . ttraverse f   = ttraverse (t . f)  -- naturality
    ttraverse Identity = Identity           -- identity
    ttraverse (Compose . fmap g . f) = Compose . fmap (ttraverse g) . ttraverse f -- composition

There is a default `ttraverse` implementation for `Generic` types, so instances can derived automatically.

Minimal complete definition

Nothing

Methods

ttraverse :: Applicative e => (forall a. f a -> e (g a)) -> t f x -> e (t g x) Source #

default ttraverse :: (Applicative e, CanDeriveTraversableT t f g x) => (forall a. f a -> e (g a)) -> t f x -> e (t g x) Source #

#### Instances

Instances details

TraversableT Lift Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f g (x :: k'). Applicative e => (forall (a :: k). f a -> e (g a)) -> Lift f x -> e (Lift g x) Source #
TraversableT MaybeT Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f g (x :: k'). Applicative e => (forall (a :: k). f a -> e (g a)) -> MaybeT f x -> e (MaybeT g x) Source #
TraversableT (ExceptT e :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e0 f g (x :: k'). Applicative e0 => (forall (a :: k). f a -> e0 (g a)) -> ExceptT e f x -> e0 (ExceptT e g x) Source #
TraversableT (WriterT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f g (x :: k'). Applicative e => (forall (a :: k). f a -> e (g a)) -> WriterT w f x -> e (WriterT w g x) Source #
TraversableT (WriterT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f g (x :: k'). Applicative e => (forall (a :: k). f a -> e (g a)) -> WriterT w f x -> e (WriterT w g x) Source #
TraversableT (Backwards :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f g (x :: k'0). Applicative e => (forall (a :: k). f a -> e (g a)) -> Backwards f x -> e (Backwards g x) Source #
TraversableT (IdentityT :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f g (x :: k'0). Applicative e => (forall (a :: k). f a -> e (g a)) -> IdentityT f x -> e (IdentityT g x) Source #
TraversableT (Reverse :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f g (x :: k'0). Applicative e => (forall (a :: k). f a -> e (g a)) -> Reverse f x -> e (Reverse g x) Source #
TraversableT (Product f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f0 g (x :: k'0). Applicative e => (forall (a :: k). f0 a -> e (g a)) -> Product f f0 x -> e (Product f g x) Source #
TraversableT (Sum f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f0 g (x :: k'0). Applicative e => (forall (a :: k). f0 a -> e (g a)) -> Sum f f0 x -> e (Sum f 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 #
Traversable f => TraversableT (Compose f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.TraversableT Methods ttraverse :: forall e f0 g (x :: k'0). Applicative e => (forall (a :: k). f0 a -> e (g a)) -> Compose f f0 x -> e (Compose f g x) Source #

## Utility functions

ttraverse_ :: (TraversableT t, Applicative e) => (forall a. f a -> e c) -> t f x -> e () Source #

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

tfoldMap :: (TraversableT t, Monoid m) => (forall a. f a -> m) -> t f x -> m Source #

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

tsequence :: (Applicative e, TraversableT t) => t (Compose e f) x -> e (t f x) Source #

Evaluate each action in the structure from left to right, and collect the results.

tsequence' :: (Applicative e, TraversableT t) => t e x -> e (t Identity x) Source #

A version of `tsequence` with `f` specialized to `Identity`.

# Distributive

class FunctorT t => DistributiveT (t :: (Type -> Type) -> i -> Type) where Source #

A `FunctorT` where the effects can be distributed to the fields: `tdistribute` turns an effectful way of building a transformer-type into a pure transformer-type with effectful ways of computing the values of its fields.

This class is the categorical dual of `TraversableT`, with `tdistribute` the dual of `tsequence` and `tcotraverse` the dual of `ttraverse`. As such, instances need to satisfy these laws:

    tdistribute . h = tmap (Compose . h . getCompose) . tdistribute    -- naturality
    tdistribute . Identity = tmap (Compose . Identity)                 -- identity
    tdistribute . Compose = fmap (Compose . Compose . fmap getCompose . getCompose) . tdistribute . fmap distribute -- composition

By specializing `f` to `((->) a)` and `g` to `Identity`, we can define a function that decomposes a function on distributive transformers into a collection of simpler functions:

    tdecompose :: DistributiveT b => (a -> b Identity) -> b ((->) a)
    tdecompose = tmap (fmap runIdentity . getCompose) . tdistribute

Lawful instances of the class can then be characterized as those that satisfy:

    trecompose . tdecompose = id
    tdecompose . trecompose = id

This means intuitively that instances need to have a fixed shape (i.e. no sum-types can be involved). Typically, this means record types, as long as they don't contain fields where the functor argument is not applied.

There is a default implementation of `tdistribute` based on `Generic`. Intuitively, it works on product types where the shape of a pure value is uniquely defined and every field is covered by the argument `f`.

Minimal complete definition

Nothing

Methods

tdistribute :: Functor f => f (t g x) -> t (Compose f g) x Source #

default tdistribute :: forall f g x. CanDeriveDistributiveT t f g x => f (t g x) -> t (Compose f g) x Source #

#### Instances

Instances details

DistributiveT MaybeT Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (MaybeT g x) -> MaybeT (Compose f g) x Source #
DistributiveT (Backwards :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (Backwards g x) -> Backwards (Compose f g) x Source #
DistributiveT (AccumT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (AccumT w g x) -> AccumT w (Compose f g) x Source #
DistributiveT (ExceptT e :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (ExceptT e g x) -> ExceptT e (Compose f g) x Source #
DistributiveT (IdentityT :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (IdentityT g x) -> IdentityT (Compose f g) x Source #
DistributiveT (ReaderT r :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (ReaderT r g x) -> ReaderT r (Compose f g) x Source #
DistributiveT (StateT s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (StateT s g x) -> StateT s (Compose f g) x Source #
DistributiveT (StateT s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (StateT s g x) -> StateT s (Compose f g) x Source #
DistributiveT (WriterT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (WriterT w g x) -> WriterT w (Compose f g) x Source #
DistributiveT (WriterT w :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (WriterT w g x) -> WriterT w (Compose f g) x Source #
DistributiveT (Reverse :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (Reverse g x) -> Reverse (Compose f g) x Source #
Distributive f => DistributiveT (Compose f :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f0 (g :: Type -> Type) (x :: i). Functor f0 => f0 (Compose f g x) -> Compose f (Compose f0 g) x Source #
DistributiveT (RWST r w s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (RWST r w s g x) -> RWST r w s (Compose f g) x Source #
DistributiveT (RWST r w s :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.DistributiveT Methods tdistribute :: forall f (g :: Type -> Type) (x :: i). Functor f => f (RWST r w s g x) -> RWST r w s (Compose 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 #

tdistribute' :: (DistributiveT t, Functor f) => f (t Identity x) -> t f x Source #

A version of `tdistribute` with `g` specialized to `Identity`.

tcotraverse :: (DistributiveT t, Functor f) => (forall a. f (g a) -> f a) -> f (t g x) -> t f x Source #

Dual of `ttraverse`

tdecompose :: DistributiveT t => (a -> t Identity x) -> t ((->) a) x Source #

Decompose a function returning a distributive transformer, into a collection of simpler functions.

trecompose :: FunctorT t => t ((->) a) x -> a -> t Identity x Source #

Recompose a decomposed function.

# Applicative

class FunctorT t => ApplicativeT (t :: (k -> Type) -> k' -> Type) where Source #

A `FunctorT` with application, providing operations to:

- embed an "empty" value (`tpure`)
- align and combine values (`tprod`)

It should satisfy the following laws:

Naturality of `tprod`

    tmap ((Pair a b) -> Pair (f a) (g b)) (u `tprod' v) = tmap f u `tprod' tmap g v

Left and right identity

    tmap ((Pair _ b) -> b) (tpure e `tprod' v) = v
    tmap ((Pair a _) -> a) (u `tprod' tpure e) = u

Associativity

    tmap ((Pair a (Pair b c)) -> Pair (Pair a b) c) (u `tprod' (v `tprod' w)) = (u `tprod' v) `tprod' w

It is to `FunctorT` in the same way is `Applicative` relates to `Functor`. For a presentation of `Applicative` as a monoidal functor, see Section 7 of Applicative Programming with Effects.

There is a default implementation of `tprod` and `tpure` based on `Generic`. Intuitively, it works on types where the value of `tpure` is uniquely defined. This corresponds rougly to record types (in the presence of sums, there would be several candidates for `tpure`), where every field is either a `Monoid` or covered by the argument `f`.

Minimal complete definition

Nothing

Methods

tpure :: (forall a. f a) -> t f x Source #

default tpure :: CanDeriveApplicativeT t f f x => (forall a. f a) -> t f x Source #

tprod :: t f x -> t g x -> t (f `Product` g) x Source #

default tprod :: CanDeriveApplicativeT t f g x => t f x -> t g x -> t (f `Product` g) x Source #

#### Instances

Instances details

ApplicativeT (Reverse :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.ApplicativeT Methods tpure :: forall f (x :: k'0). (forall (a :: k). f a) -> Reverse f x Source # tprod :: forall (f :: k -> Type) (x :: k'0) (g :: k -> Type). Reverse f x -> Reverse g x -> Reverse (Product f g) x Source #
Alternative f => ApplicativeT (Product f :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.ApplicativeT Methods tpure :: forall f0 (x :: k'). (forall (a :: k). f0 a) -> Product f f0 x Source # tprod :: forall (f0 :: k -> Type) (x :: k') (g :: k -> Type). Product f f0 x -> Product f g x -> Product f (Product f0 g) x Source #
Alternative f => ApplicativeT (Sum f :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.ApplicativeT Methods tpure :: forall f0 (x :: k'). (forall (a :: k). f0 a) -> Sum f f0 x Source # tprod :: forall (f0 :: k -> Type) (x :: k') (g :: k -> Type). Sum f f0 x -> Sum f g x -> Sum f (Product f0 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 #
Applicative f => ApplicativeT (Compose f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.ApplicativeT Methods tpure :: forall f0 (x :: k'0). (forall (a :: k). f0 a) -> Compose f f0 x Source # tprod :: forall (f0 :: k -> Type) (x :: k'0) (g :: k -> Type). Compose f f0 x -> Compose f g x -> Compose f (Product f0 g) x Source #

## Utility functions

tzip :: ApplicativeT t => t f x -> t g x -> t (f `Product` g) x Source #

An alias of `tprod`.

tunzip :: ApplicativeT t => t (f `Product` g) x -> (t f x, t g x) Source #

An equivalent of `unzip`.

tzipWith :: ApplicativeT t => (forall a. f a -> g a -> h a) -> t f x -> t g x -> t h x Source #

An equivalent of `zipWith`.

tzipWith3 :: ApplicativeT t => (forall a. f a -> g a -> h a -> i a) -> t f x -> t g x -> t h x -> t i x Source #

An equivalent of `zipWith3`.

tzipWith4 :: ApplicativeT t => (forall a. f a -> g a -> h a -> i a -> j a) -> t f x -> t g x -> t h x -> t i x -> t j x Source #

An equivalent of `zipWith4`.

# Monad

class FunctorT t => MonadT t where Source #

Some endo-functors on indexed-types are monads. Common examples would be "functor-transformers", like `Compose` or `ReaderT`. In that sense, `MonadT` is similar to `MonadTrans` but with additional structure (see also mmorph's `MMonad` class).

Notice though that while `lift` assumes a `Monad` instance of the value to be lifted, `tlift` has no such constraint. This means we cannot have instances for most "monad transformers", since lifting typically involves an `fmap`.

`MonadT` also corresponds to the indexed-monad of Kleisli arrows of outrageous fortune.

Instances of this class should to satisfy the monad laws. They laws can stated either in terms of `(`tlift`, `tjoin`)` or `(`tlift`, `tembed`)`. In the former:

    tmap h . tlift = tlift . h
    tmap h . tjoin = tjoin . tmap (tmap h)
    tjoin . tlift  = id
    tjoin . 'tmap tlift' = id
    tjoin . tjoin = tjoin . tmap tjoin

In the latter:

    tembed f . tlift = f
    tembed tlift = id
    tembed f . tembed g = tembed (tembed f . g)

Minimal complete definition

tlift, tjoin | tlift, tembed

Methods

tlift :: f a -> t f a Source #

Lift a functor to a transformed functor.

tjoin :: t (t f) a -> t f a Source #

The conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

tembed :: MonadT t => (forall x. f x -> t g x) -> t f a -> t g a Source #

Analogous to `(`=<<`)`.

#### Instances

Instances details

MonadT Lift Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f (a :: k'). f a -> Lift f a Source # tjoin :: forall (f :: k' -> Type) (a :: k'). Lift (Lift f) a -> Lift f a Source # tembed :: forall f (g :: k' -> Type) (a :: k'). MonadT Lift => (forall (x :: k'). f x -> Lift g x) -> Lift f a -> Lift g a Source #
MonadT (ReaderT r :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f (a :: k'). f a -> ReaderT r f a Source # tjoin :: forall (f :: k' -> Type) (a :: k'). ReaderT r (ReaderT r f) a -> ReaderT r f a Source # tembed :: forall f (g :: k' -> Type) (a :: k'). MonadT (ReaderT r) => (forall (x :: k'). f x -> ReaderT r g x) -> ReaderT r f a -> ReaderT r g a Source #
MonadT (Backwards :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f (a :: k'0). f a -> Backwards f a Source # tjoin :: forall (f :: k'0 -> Type) (a :: k'0). Backwards (Backwards f) a -> Backwards f a Source # tembed :: forall f (g :: k'0 -> Type) (a :: k'0). MonadT Backwards => (forall (x :: k'0). f x -> Backwards g x) -> Backwards f a -> Backwards g a Source #
MonadT (IdentityT :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f (a :: k'0). f a -> IdentityT f a Source # tjoin :: forall (f :: k'0 -> Type) (a :: k'0). IdentityT (IdentityT f) a -> IdentityT f a Source # tembed :: forall f (g :: k'0 -> Type) (a :: k'0). MonadT IdentityT => (forall (x :: k'0). f x -> IdentityT g x) -> IdentityT f a -> IdentityT g a Source #
MonadT (Reverse :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f (a :: k'0). f a -> Reverse f a Source # tjoin :: forall (f :: k'0 -> Type) (a :: k'0). Reverse (Reverse f) a -> Reverse f a Source # tembed :: forall f (g :: k'0 -> Type) (a :: k'0). MonadT Reverse => (forall (x :: k'0). f x -> Reverse g x) -> Reverse f a -> Reverse g a Source #
Alternative f => MonadT (Product f :: (Type -> Type) -> Type -> Type) Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f0 (a :: k'). f0 a -> Product f f0 a Source # tjoin :: forall (f0 :: k' -> Type) (a :: k'). Product f (Product f f0) a -> Product f f0 a Source # tembed :: forall f0 (g :: k' -> Type) (a :: k'). MonadT (Product f) => (forall (x :: k'). f0 x -> Product f g x) -> Product f f0 a -> Product f g a Source #
MonadT (Sum f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f0 (a :: k'0). f0 a -> Sum f f0 a Source # tjoin :: forall (f0 :: k'0 -> Type) (a :: k'0). Sum f (Sum f f0) a -> Sum f f0 a Source # tembed :: forall f0 (g :: k'0 -> Type) (a :: k'0). MonadT (Sum f) => (forall (x :: k'0). f0 x -> Sum f g x) -> Sum f f0 a -> Sum f g a Source #
Monad f => MonadT (Compose f :: (k' -> Type) -> k' -> Type) Source # |
Instance details Defined in Barbies.Internal.MonadT Methods tlift :: forall f0 (a :: k'0). f0 a -> Compose f f0 a Source # tjoin :: forall (f0 :: k'0 -> Type) (a :: k'0). Compose f (Compose f f0) a -> Compose f f0 a Source # tembed :: forall f0 (g :: k'0 -> Type) (a :: k'0). MonadT (Compose f) => (forall (x :: k'0). f0 x -> Compose f g x) -> Compose f f0 a -> Compose f g a Source #

# Constraints and instance dictionaries

class FunctorT t => ConstraintsT (t :: (kl -> Type) -> kr -> Type) where Source #

Instances of this class provide means to talk about constraints, both at compile-time, using `AllT`, and at run-time, in the form of `Dict`, via `taddDicts`.

A manual definition would look like this:

    data T f a = A (f Int) (f String) | B (f Bool) (f Int)

    instance ConstraintsT T where
      type AllT c T = (c Int, c String, c Bool)

      taddDicts t = case t of
        A x y -> A (Pair Dict x) (Pair Dict y)
        B z w -> B (Pair Dict z) (Pair Dict w)

Now, when we given a `T f`, if we need to use the `Show` instance of their fields, we can use:

    taddDicts :: AllT Show t => t f -> t (Dict Show `Product' f)

There is a default implementation of `ConstraintsT` for `Generic` types, so in practice one will simply do:

    derive instance Generic (T f a)
    instance ConstraintsT T

Minimal complete definition

Nothing

Associated Types

type AllT (c :: k -> Constraint) t :: Constraint Source #

``AllT` c t` should contain a constraint `c a` for each `a` occurring under an `f` in `t f`.

For requiring constraints of the form `c (f a)`, use `AllTF`.

type AllT c t = GAll 1 c (GAllRepT t)

Methods

taddDicts :: forall c f x. AllT c t => t f x -> t (Dict c `Product` f) x Source #

default taddDicts :: forall c f x. (CanDeriveConstraintsT c t f x, AllT c t) => t f x -> t (Dict c `Product` f) x Source #

type AllTF c f t = AllT (ClassF c f) t Source #

Similar to `AllT` but will put the functor argument `f` between the constraint `c` and the type `a`.

## Utility functions

tmapC :: forall c t f g x. (AllT c t, ConstraintsT t) => (forall a. c a => f a -> g a) -> t f x -> t g x Source #

Like `tmap` but a constraint is allowed to be required on each element of `t`.

ttraverseC :: forall c t f g e x. (TraversableT t, ConstraintsT t, AllT c t, Applicative e) => (forall a. c a => f a -> e (g a)) -> t f x -> e (t g x) Source #

Like `ttraverse` but with a constraint on the elements of `t`.

# Support for generic derivations

newtype Rec (p :: Type) a x Source #

Constructors

Rec |

Fields

- unRec :: K1 R a x

#### Instances

Instances details

GTraversable (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (Rec a a :: k3 -> Type) (Rec a a :: k3 -> Type) Source # |
Instance details Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k20). Applicative t => Proxy n -> (forall (a0 :: k10). f a0 -> t (g a0)) -> Rec a a x -> t (Rec a a x) Source #
Monoid x => GApplicative (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (Rec x x :: k3 -> Type) (Rec x x :: k3 -> Type) (Rec x x :: k3 -> Type) Source # |
Instance details Defined in Barbies.Generics.Applicative Methods gprod :: forall (x0 :: k10). Proxy n -> Proxy f -> Proxy g -> Rec x x x0 -> Rec x x x0 -> Rec x x x0 Source # gpure :: forall (x0 :: k10). (f ~ g, Rec x x ~ Rec x x) => Proxy n -> Proxy f -> Proxy (Rec x x) -> Proxy (Rec x x) -> (forall (a :: k20). f a) -> Rec x x x0 Source #
GConstraints n (c :: k1 -> Constraint) (f :: k2) (Rec a' a :: Type -> Type) (Rec b' b :: k3 -> Type) (Rec b' b :: k3 -> Type) Source # |
Instance details Defined in Barbies.Generics.Constraints Methods gaddDicts :: forall (x :: k20). GAll n c (Rec a' a) => Rec b' b x -> Rec b' b x Source #
GFunctor n (f :: k1 -> Type) (g :: k1 -> Type) (Rec x x :: k2 -> Type) (Rec x x :: k2 -> Type) Source # |
Instance details Defined in Barbies.Generics.Functor Methods gmap :: forall (x0 :: k10). Proxy n -> (forall (a :: k). f a -> g a) -> Rec x x x0 -> Rec x x x0 Source #
repbi ~ repbb => GBare n (Rec repbi repbi :: k -> Type) (Rec repbb repbb :: k -> Type) Source # |
Instance details Defined in Barbies.Generics.Bare Methods gstrip :: forall (x :: k0). Proxy n -> Rec repbi repbi x -> Rec repbb repbb x Source # gcover :: forall (x :: k0). Proxy n -> Rec repbb repbb x -> Rec repbi repbi x Source #
type GAll n (c :: k -> Constraint) (Rec l r :: Type -> Type) Source # |
Instance details Defined in Barbies.Generics.Constraints type GAll n (c :: k -> Constraint) (Rec l r :: Type -> Type)