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

Stability | experimental |

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

- newtype Tagged s b = Tagged {
- unTagged :: b

- retag :: Tagged s b -> Tagged t b
- untag :: Tagged s b -> b
- tagSelf :: a -> Tagged a a
- untagSelf :: Tagged a a -> a
- asTaggedTypeOf :: s -> Tagged s b -> s
- data Proxy p = Proxy
- reproxy :: Proxy s -> Proxy t
- asProxyTypeOf :: a -> Proxy a -> a
- proxy :: Tagged s a -> Proxy s -> a
- unproxy :: (Proxy s -> a) -> Tagged s a

# 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

Typeable2 Tagged | |

Monad (Tagged s) | |

Functor (Tagged s) | |

Applicative (Tagged s) | |

Foldable (Tagged s) | |

Traversable (Tagged s) | |

Bounded b => Bounded (Tagged s b) | |

Enum b => Enum (Tagged s b) | |

Eq b => Eq (Tagged s b) | |

Floating b => Floating (Tagged s b) | |

Fractional b => Fractional (Tagged s b) | |

Integral b => Integral (Tagged s b) | |

(Data s, Data b) => Data (Tagged s b) | |

Num b => Num (Tagged s b) | |

Ord b => Ord (Tagged s b) | |

Read b => Read (Tagged s b) | |

Real b => Real (Tagged s b) | |

RealFloat b => RealFloat (Tagged s b) | |

RealFrac b => RealFrac (Tagged s b) | |

Show b => Show (Tagged s b) | |

Ix b => Ix (Tagged s b) |

retag :: Tagged s b -> Tagged t 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

asTaggedTypeOf :: s -> Tagged s 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.

# Proxy values

reproxy :: Proxy s -> Proxy tSource

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 reproxySucc :: Proxy n -> Proxy (Succ n) reproxySucc = reproxy

asProxyTypeOf :: a -> Proxy a -> aSource

`asProxyTypeOf`

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.