Safe Haskell | None |
---|

This module defines `Binary`

and `Hashable`

instances for `TypeRep`

. These are defined on a newtype of `TypeRep`

, namely `ConcreteTypeRep`

, for two purposes:

- to avoid making orphan instances
- the
`Hashable`

instance for`ConcreteTypeRep`

may not be pure enough for some people's tastes.

As usual with `Typeable`

, this module will typically be used with some variant of `Data.Dynamic`

. Two possible uses of this module are:

- making hashmaps:
`HashMap`

`ConcreteTypeRep`

Dynamic - serializing
`Dynamic`

s.

- data ConcreteTypeRep
- cTypeOf :: Typeable a => a -> ConcreteTypeRep
- toTypeRep :: ConcreteTypeRep -> TypeRep
- fromTypeRep :: TypeRep -> ConcreteTypeRep

# Documentation

data ConcreteTypeRep Source

Abstract type providing the functionality of `TypeRep`

, but additionally supporting hashing and serialization.

The `Eq`

instance is just the `Eq`

instance for `TypeRep`

, so an analogous guarantee holds:

if and only if `cTypeOf`

a == `cTypeOf`

b`a`

and `b`

have the same type.
The hashing and serialization functions preserve this equality.

Eq ConcreteTypeRep | |

Show ConcreteTypeRep | |

Typeable ConcreteTypeRep | |

Binary ConcreteTypeRep | |

Hashable ConcreteTypeRep | This instance is guaranteed to be consistent for a single run of the program, but not for multiple runs. |

cTypeOf :: Typeable a => a -> ConcreteTypeRepSource

"Concrete" version of `typeOf`

.

toTypeRep :: ConcreteTypeRep -> TypeRepSource

Converts to the underlying `TypeRep`

fromTypeRep :: TypeRep -> ConcreteTypeRepSource

Converts from the underlying `TypeRep`