base-4.3.1.0: Basic libraries

Portability | portable
Stability | experimental
Maintainer | libraries@haskell.org

Data.Typeable

Contents

- The Typeable class
- Type-safe cast
- Type representations
- Construction of type representations
- Observation of type representations
- The other Typeable classes
- Default instances

Description

The `Typeable` class reifies types to some extent by associating type representations to types. These type representations can be compared, and one can in turn define a type-safe cast operation. To this end, an unsafe cast is guarded by a test for type (representation) equivalence. The module Data.Dynamic uses Typeable for an implementation of dynamics. The module Data.Data uses Typeable and type-safe cast (but not dynamics) to support the "Scrap your boilerplate" style of generic programming.

Synopsis

- class Typeable a where
  - typeOf :: a -> TypeRep
- cast :: (Typeable a, Typeable b) => a -> Maybe b
- gcast :: (Typeable a, Typeable b) => c a -> Maybe (c b)
- data TypeRep
- data TyCon
- showsTypeRep :: TypeRep -> ShowS
- mkTyCon :: String -> TyCon
- mkTyConApp :: TyCon -> [TypeRep] -> TypeRep
- mkAppTy :: TypeRep -> TypeRep -> TypeRep
- mkFunTy :: TypeRep -> TypeRep -> TypeRep
- splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
- funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
- typeRepTyCon :: TypeRep -> TyCon
- typeRepArgs :: TypeRep -> [TypeRep]
- tyConString :: TyCon -> String
- typeRepKey :: TypeRep -> IO Int
- class Typeable1 t where
  - typeOf1 :: t a -> TypeRep
- class Typeable2 t where
  - typeOf2 :: t a b -> TypeRep
- class Typeable3 t where
  - typeOf3 :: t a b c -> TypeRep
- class Typeable4 t where
  - typeOf4 :: t a b c d -> TypeRep
- class Typeable5 t where
  - typeOf5 :: t a b c d e -> TypeRep
- class Typeable6 t where
  - typeOf6 :: t a b c d e f -> TypeRep
- class Typeable7 t where
  - typeOf7 :: t a b c d e f g -> TypeRep
- gcast1 :: (Typeable1 t, Typeable1 t') => c (t a) -> Maybe (c (t' a))
- gcast2 :: (Typeable2 t, Typeable2 t') => c (t a b) -> Maybe (c (t' a b))
- typeOfDefault :: forall t a. (Typeable1 t, Typeable a) => t a -> TypeRep
- typeOf1Default :: forall t a b. (Typeable2 t, Typeable a) => t a b -> TypeRep
- typeOf2Default :: forall t a b c. (Typeable3 t, Typeable a) => t a b c -> TypeRep
- typeOf3Default :: forall t a b c d. (Typeable4 t, Typeable a) => t a b c d -> TypeRep
- typeOf4Default :: forall t a b c d e. (Typeable5 t, Typeable a) => t a b c d e -> TypeRep
- typeOf5Default :: forall t a b c d e f. (Typeable6 t, Typeable a) => t a b c d e f -> TypeRep
- typeOf6Default :: forall t a b c d e f g. (Typeable7 t, Typeable a) => t a b c d e f g -> TypeRep

# The Typeable class

class Typeable a where Source

The class `Typeable` allows a concrete representation of a type to be calculated.

Methods

typeOf :: a -> TypeRep Source

Takes a value of type `a` and returns a concrete representation of that type. The value of the argument should be ignored by any instance of `Typeable`, so that it is safe to pass `undefined` as the argument.

Instances

Typeable Bool |
Typeable Char |
Typeable Double |
Typeable Float |
Typeable Int |
Typeable Int8 |
Typeable Int16 |
Typeable Int32 |
Typeable Int64 |
Typeable Integer |
Typeable Ordering |
Typeable RealWorld |
Typeable Word |
Typeable Word8 |
Typeable Word16 |
Typeable Word32 |
Typeable Word64 |
Typeable () |
Typeable TyCon |
Typeable TypeRep |
Typeable ArithException |
Typeable ErrorCall |
Typeable SomeException |
Typeable IOException |
Typeable CUIntMax |
Typeable CIntMax |
Typeable CUIntPtr |
Typeable CIntPtr |
Typeable CTime |
Typeable CClock |
Typeable CSigAtomic |
Typeable CWchar |
Typeable CSize |
Typeable CPtrdiff |
Typeable CDouble |
Typeable CFloat |
Typeable CULLong |
Typeable CLLong |
Typeable CULong |
Typeable CLong |
Typeable CUInt |
Typeable CInt |
Typeable CUShort |
Typeable CShort |
Typeable CUChar |
Typeable CSChar |
Typeable CChar |
Typeable Dynamic |
Typeable IntPtr |
Typeable WordPtr |
Typeable Handle__ |
Typeable Handle |
Typeable ExitCode |
Typeable ArrayException |
Typeable AsyncException |
Typeable AssertionFailed |
Typeable Deadlock |
Typeable BlockedIndefinitelyOnSTM |
Typeable BlockedIndefinitelyOnMVar |
Typeable BlockedIndefinitely |
Typeable BlockedOnDeadMVar |
Typeable ThreadId |
Typeable NestedAtomically |
Typeable NonTermination |
Typeable NoMethodError |
Typeable RecUpdError |
Typeable RecConError |
Typeable RecSelError |
Typeable PatternMatchFail |
Typeable Fd |
Typeable CRLim |
Typeable CTcflag |
Typeable CSpeed |
Typeable CCc |
Typeable CUid |
Typeable CNlink |
Typeable CGid |
Typeable CSsize |
Typeable CPid |
Typeable COff |
Typeable CMode |
Typeable CIno |
Typeable CDev |
Typeable FD |
Typeable SpecConstrAnnotation |
Typeable Unique |
Typeable QSem |
Typeable QSemN |
Typeable Timeout |
Typeable E12 |
Typeable E9 |
Typeable E6 |
Typeable E3 |
Typeable E2 |
Typeable E1 |
Typeable E0 |
Typeable Version |
Typeable Exception |
(Typeable1 s, Typeable a) => Typeable (s a) | One Typeable instance for all Typeable1 instances

# Type-safe cast

cast :: (Typeable a, Typeable b) => a -> Maybe bSource

The type-safe cast operation

gcast :: (Typeable a, Typeable b) => c a -> Maybe (c b)Source

A flexible variation parameterised in a type constructor

# Type representations

data TypeRep Source

A concrete representation of a (monomorphic) type. `TypeRep` supports reasonably efficient equality.

Instances

Eq TypeRep |
Show TypeRep |
Typeable TypeRep |

data TyCon Source

An abstract representation of a type constructor. `TyCon` objects can be built using `mkTyCon`.

Instances

Eq TyCon |
Show TyCon |
Typeable TyCon |

showsTypeRep :: TypeRep -> ShowS Source

# Construction of type representations

mkTyConSource

Arguments

:: String | the name of the type constructor (should be unique in the program, so it might be wise to use the fully qualified name).
-> TyCon | A unique `TyCon` object

Builds a `TyCon` object representing a type constructor. An implementation of Data.Typeable should ensure that the following holds:

      mkTyCon "a" == mkTyCon "a"

mkTyConApp :: TyCon -> [TypeRep] -> TypeRep Source

Applies a type constructor to a sequence of types

mkAppTy :: TypeRep -> TypeRep -> TypeRep Source

Adds a TypeRep argument to a TypeRep.

mkFunTy :: TypeRep -> TypeRep -> TypeRep Source

A special case of `mkTyConApp`, which applies the function type constructor to a pair of types.

# Observation of type representations

splitTyConApp :: TypeRep -> (TyCon, [TypeRep])Source

Splits a type constructor application

funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep Source

Applies a type to a function type. Returns: ``Just` u` if the first argument represents a function of type `t -> u` and the second argument represents a function of type `t`. Otherwise, returns `Nothing`.

typeRepTyCon :: TypeRep -> TyCon Source

Observe the type constructor of a type representation

typeRepArgs :: TypeRep -> [TypeRep]Source

Observe the argument types of a type representation

tyConString :: TyCon -> String Source

Observe string encoding of a type representation

typeRepKey :: TypeRep -> IO Int Source

Returns a unique integer associated with a `TypeRep`. This can be used for making a mapping with TypeReps as the keys, for example. It is guaranteed that `t1 == t2` if and only if `typeRepKey t1 == typeRepKey t2`.

It is in the `IO` monad because the actual value of the key may vary from run to run of the program. You should only rely on the equality property, not any actual key value. The relative ordering of keys has no meaning either.

# The other Typeable classes

Note: The general instances are provided for GHC only.

class Typeable1 t where Source

Variant for unary type constructors

Methods

typeOf1 :: t a -> TypeRep Source

Instances

Typeable1 [] |
Typeable1 Ratio |
Typeable1 StablePtr |
Typeable1 IO |
Typeable1 Ptr |
Typeable1 FunPtr |
Typeable1 Maybe |
Typeable1 MVar |
Typeable1 IORef |
Typeable1 ForeignPtr |
Typeable1 Weak |
Typeable1 TVar |
Typeable1 STM |
Typeable1 Chan |
Typeable1 Complex |
Typeable1 Fixed |
Typeable1 StableName |
(Typeable2 s, Typeable a) => Typeable1 (s a) | One Typeable1 instance for all Typeable2 instances

class Typeable2 t where Source

Variant for binary type constructors

Methods

typeOf2 :: t a b -> TypeRep Source

Instances

Typeable2 (->) |
Typeable2 Either |
Typeable2 (,) |
Typeable2 ST |
Typeable2 Array |
Typeable2 IOArray |
Typeable2 STRef |
(Typeable3 s, Typeable a) => Typeable2 (s a) | One Typeable2 instance for all Typeable3 instances

class Typeable3 t where Source

Variant for 3-ary type constructors

Methods

typeOf3 :: t a b c -> TypeRep Source

Instances

Typeable3 (,,) |
Typeable3 STArray |
(Typeable4 s, Typeable a) => Typeable3 (s a) | One Typeable3 instance for all Typeable4 instances

class Typeable4 t where Source

Variant for 4-ary type constructors

Methods

typeOf4 :: t a b c d -> TypeRep Source

Instances

Typeable4 (,,,) |
(Typeable5 s, Typeable a) => Typeable4 (s a) | One Typeable4 instance for all Typeable5 instances

class Typeable5 t where Source

Variant for 5-ary type constructors

Methods

typeOf5 :: t a b c d e -> TypeRep Source

Instances

Typeable5 (,,,,) |
(Typeable6 s, Typeable a) => Typeable5 (s a) | One Typeable5 instance for all Typeable6 instances

class Typeable6 t where Source

Variant for 6-ary type constructors

Methods

typeOf6 :: t a b c d e f -> TypeRep Source

Instances

Typeable6 (,,,,,) |
(Typeable7 s, Typeable a) => Typeable6 (s a) | One Typeable6 instance for all Typeable7 instances

class Typeable7 t where Source

Variant for 7-ary type constructors

Methods

typeOf7 :: t a b c d e f g -> TypeRep Source

Instances

Typeable7 (,,,,,,) |

gcast1 :: (Typeable1 t, Typeable1 t') => c (t a) -> Maybe (c (t' a))Source

Cast for * -> *

gcast2 :: (Typeable2 t, Typeable2 t') => c (t a b) -> Maybe (c (t' a b))Source

Cast for * -> * -> *

# Default instances

Note: These are not needed by GHC, for which these instances are generated by general instance declarations.

typeOfDefault :: forall t a. (Typeable1 t, Typeable a) => t a -> TypeRep Source

For defining a `Typeable` instance from any `Typeable1` instance.

typeOf1Default :: forall t a b. (Typeable2 t, Typeable a) => t a b -> TypeRep Source

For defining a `Typeable1` instance from any `Typeable2` instance.

typeOf2Default :: forall t a b c. (Typeable3 t, Typeable a) => t a b c -> TypeRep Source

For defining a `Typeable2` instance from any `Typeable3` instance.

typeOf3Default :: forall t a b c d. (Typeable4 t, Typeable a) => t a b c d -> TypeRep Source

For defining a `Typeable3` instance from any `Typeable4` instance.

typeOf4Default :: forall t a b c d e. (Typeable5 t, Typeable a) => t a b c d e -> TypeRep Source

For defining a `Typeable4` instance from any `Typeable5` instance.

typeOf5Default :: forall t a b c d e f. (Typeable6 t, Typeable a) => t a b c d e f -> TypeRep Source

For defining a `Typeable5` instance from any `Typeable6` instance.

typeOf6Default :: forall t a b c d e f g. (Typeable7 t, Typeable a) => t a b c d e f g -> TypeRep Source

For defining a `Typeable6` instance from any `Typeable7` instance.