Portability | portable |
---|---|

Stability | experimental |

Maintainer | Edward Kmett <ekmett@gmail.com> |

Safe Haskell | Trustworthy |

- newtype TaggedT s m b = TagT {
- untagT :: m b

- tag :: m b -> TaggedT s m b
- self :: Applicative m => a -> TaggedT a m a
- selfM :: Monad m => a -> TaggedT s m a
- untag :: TaggedT s m b -> m b
- retag :: TaggedT s m b -> TaggedT t m b
- mapTaggedT :: (m a -> n b) -> TaggedT s m a -> TaggedT s n b
- reflected :: forall s m a. (Applicative m, Reifies s a) => TaggedT s m a
- reflectedM :: forall s m a. (Monad m, Reifies s a) => TaggedT s m a
- asTaggedTypeOf :: s -> TaggedT s m b -> s

# Tagged values

A

value is a value `Tagged`

s b`b`

with an attached phantom type `s`

.
This can be used in place of the more traditional but less safe idiom of
passing in an undefined value with the type, because unlike an `(s -> b)`

,
a

can't try to use the argument `Tagged`

s b`s`

as a real value.

Moreover, you don't have to rely on the compiler to inline away the extra argument, because the newtype is free

self :: Applicative m => a -> TaggedT a m aSource

Tag value with its own type in `Applicative`

context

retag :: TaggedT s m b -> TaggedT t m bSource

Some times you need to change the tag you have lying around.
Idiomatic usage is to make a new combinator for the relationship between the
tags that you want to enforce, and define that combinator using `retag`

.

data Succ n retagSucc :: Tagged n a -> Tagged (Succ n) a retagSucc = retag

mapTaggedT :: (m a -> n b) -> TaggedT s m a -> TaggedT s n bSource

Lift an operation on underlying monad

reflected :: forall s m a. (Applicative m, Reifies s a) => TaggedT s m aSource

Reflect reified value back in `Applicative`

context

reflectedM :: forall s m a. (Monad m, Reifies s a) => TaggedT s m aSource

Reflect reified value back in `Monad`

context

asTaggedTypeOf :: s -> TaggedT s m b -> sSource

`asTaggedTypeOf`

is a type-restricted version of `const`

. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the tag of the second.