base-4.7.0.0: Basic libraries

Copyright | (c) The University of Glasgow, CWI 2001--2004
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Typeable

Contents

- The Typeable class
- Propositional equality
- For backwards compatibility
- Type-safe cast
- Generalized casts for higher-order kinds
- A canonical proxy type
- Type representations
- Construction of type representations
- Observation of type representations

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.

## Compatibility Notes

Since GHC 7.8, `Typeable` is poly-kinded. The changes required for this might break some old programs involving `Typeable`. More details on this, including how to fix your code, can be found on the PolyTypeable wiki page

Synopsis

- class Typeable a
- typeRep :: forall proxy a. Typeable a => proxy a -> TypeRep
- data a :~: b where
  - Refl :: a :~: a
- typeOf :: forall a. Typeable a => a -> TypeRep
- typeOf1 :: forall t a. Typeable t => t a -> TypeRep
- typeOf2 :: forall t a b. Typeable t => t a b -> TypeRep
- typeOf3 :: forall t a b c. Typeable t => t a b c -> TypeRep
- typeOf4 :: forall t a b c d. Typeable t => t a b c d -> TypeRep
- typeOf5 :: forall t a b c d e. Typeable t => t a b c d e -> TypeRep
- typeOf6 :: forall t a b c d e f. Typeable t => t a b c d e f -> TypeRep
- typeOf7 :: forall t a b c d e f g. Typeable t => t a b c d e f g -> TypeRep
- type Typeable1 a = Typeable a
- type Typeable2 a = Typeable a
- type Typeable3 a = Typeable a
- type Typeable4 a = Typeable a
- type Typeable5 a = Typeable a
- type Typeable6 a = Typeable a
- type Typeable7 a = Typeable a
- cast :: forall a b. (Typeable a, Typeable b) => a -> Maybe b
- eqT :: forall a b. (Typeable a, Typeable b) => Maybe (a :~: b)
- gcast :: forall a b c. (Typeable a, Typeable b) => c a -> Maybe (c b)
- gcast1 :: forall c t t' a. (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
- gcast2 :: forall c t t' a b. (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
- data Proxy t = Proxy
- data TypeRep
- showsTypeRep :: TypeRep -> ShowS
- data TyCon
- tyConString :: TyCon -> String
- tyConPackage :: TyCon -> String
- tyConModule :: TyCon -> String
- tyConName :: TyCon -> String
- mkTyCon3 :: String -> String -> 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]

# The Typeable class

class Typeable a

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

Minimal complete definition

typeRep#

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 * SomeException |
Typeable * TyCon |
Typeable * TypeRep |
Typeable * ArithException |
Typeable * ErrorCall |
Typeable * IOException |
Typeable * Dynamic |
Typeable * CUIntMax |
Typeable * CIntMax |
Typeable * CUIntPtr |
Typeable * CIntPtr |
Typeable * CSUSeconds |
Typeable * CUSeconds |
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 * IntPtr |
Typeable * WordPtr |
Typeable * Handle |
Typeable * ExitCode |
Typeable * ArrayException |
Typeable * AsyncException |
Typeable * SomeAsyncException |
Typeable * AssertionFailed |
Typeable * Deadlock |
Typeable * BlockedIndefinitelyOnSTM |
Typeable * BlockedIndefinitelyOnMVar |
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 * ThreadId |
Typeable * NestedAtomically |
Typeable * NonTermination |
Typeable * NoMethodError |
Typeable * RecUpdError |
Typeable * RecConError |
Typeable * RecSelError |
Typeable * PatternMatchFail |
Typeable * QSemN |
Typeable * Version |
Typeable * E12 |
Typeable * E9 |
Typeable * E6 |
Typeable * E3 |
Typeable * E2 |
Typeable * E1 |
Typeable * E0 |
Typeable * Unique |
Typeable * SpecConstrAnnotation |
(Typeable (k1 -> k) s, Typeable k1 a) => Typeable k (s a) | Kind-polymorphic Typeable instance for type application
Typeable ((* -> *) -> Constraint) Alternative |
Typeable ((* -> *) -> Constraint) Applicative |
Typeable (* -> * -> * -> * -> * -> * -> * -> *) (,,,,,,) |
Typeable (* -> * -> * -> * -> * -> * -> *) (,,,,,) |
Typeable (* -> * -> * -> * -> * -> *) (,,,,) |
Typeable (* -> * -> * -> * -> *) (,,,) |
Typeable (* -> * -> * -> *) (,,) |
Typeable (* -> * -> *) (->) |
Typeable (* -> * -> *) Either |
Typeable (* -> * -> *) (,) |
Typeable (* -> * -> *) ST |
Typeable (* -> * -> *) STRef |
Typeable (* -> *) [] |
Typeable (* -> *) Ratio |
Typeable (* -> *) StablePtr |
Typeable (* -> *) IO |
Typeable (* -> *) Ptr |
Typeable (* -> *) FunPtr |
Typeable (* -> *) Maybe |
Typeable (* -> *) IORef |
Typeable (* -> *) MVar |
Typeable (* -> *) Weak |
Typeable (* -> *) ForeignPtr |
Typeable (* -> *) TVar |
Typeable (* -> *) STM |
Typeable (* -> *) Chan |
Typeable (* -> *) Complex |
Typeable (* -> *) Fixed |
Typeable (* -> *) StableName |
Typeable (* -> Constraint) Monoid |
Typeable (k -> k -> *) (Coercion k) |
Typeable (k -> k -> *) ((:~:) k) |
Typeable (k -> *) (Proxy k) |

typeRep :: forall proxy a. Typeable a => proxy a -> TypeRep

Takes a value of type `a` and returns a concrete representation of that type.

Since: 4.7.0.0

# Propositional equality

data a :~: b where infix 4

Propositional equality. If `a :~: b` is inhabited by some terminating value, then the type `a` is the same as the type `b`. To use this equality in practice, pattern-match on the `a :~: b` to get out the `Refl` constructor; in the body of the pattern-match, the compiler knows that `a ~ b`.

Since: 4.7.0.0

Constructors

Refl :: a :~: a |

Instances

Category k ((:~:) k) |
TestEquality k ((:~:) k a) |
TestCoercion k ((:~:) k a) |
Typeable (k -> k -> *) ((:~:) k) |
(~) k a b => Bounded ((:~:) k a b) |
(~) k a b => Enum ((:~:) k a b) |
Eq ((:~:) k a b) |
((~) * a b, Data a) => Data ((:~:) * a b) |
Ord ((:~:) k a b) |
(~) k a b => Read ((:~:) k a b) |
Show ((:~:) k a b) |

# For backwards compatibility

typeOf :: forall a. Typeable a => a -> TypeRep

typeOf1 :: forall t a. Typeable t => t a -> TypeRep

typeOf2 :: forall t a b. Typeable t => t a b -> TypeRep

typeOf3 :: forall t a b c. Typeable t => t a b c -> TypeRep

typeOf4 :: forall t a b c d. Typeable t => t a b c d -> TypeRep

typeOf5 :: forall t a b c d e. Typeable t => t a b c d e -> TypeRep

typeOf6 :: forall t a b c d e f. Typeable t => t a b c d e f -> TypeRep

typeOf7 :: forall t a b c d e f g. Typeable t => t a b c d e f g -> TypeRep

type Typeable1 a = Typeable a

Deprecated: renamed to `Typeable`

type Typeable2 a = Typeable a

Deprecated: renamed to `Typeable`

type Typeable3 a = Typeable a

Deprecated: renamed to `Typeable`

type Typeable4 a = Typeable a

Deprecated: renamed to `Typeable`

type Typeable5 a = Typeable a

Deprecated: renamed to `Typeable`

type Typeable6 a = Typeable a

Deprecated: renamed to `Typeable`

type Typeable7 a = Typeable a

Deprecated: renamed to `Typeable`

# Type-safe cast

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

The type-safe cast operation

eqT :: forall a b. (Typeable a, Typeable b) => Maybe (a :~: b)

Extract a witness of equality of two types

Since: 4.7.0.0

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

A flexible variation parameterised in a type constructor

# Generalized casts for higher-order kinds

gcast1 :: forall c t t' a. (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))

Cast over `k1 -> k2`

gcast2 :: forall c t t' a b. (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))

Cast over `k1 -> k2 -> k3`

# A canonical proxy type

data Proxy t

A concrete, poly-kinded proxy type

Constructors

Proxy |

Instances

Monad (Proxy *) |
Functor (Proxy *) |
Applicative (Proxy *) |
Foldable (Proxy *) |
Traversable (Proxy *) |
Bounded (Proxy k s) |
Enum (Proxy k s) |
Eq (Proxy k s) |
Data t => Data (Proxy * t) |
Ord (Proxy k s) |
Read (Proxy k s) |
Show (Proxy k s) |
Ix (Proxy k s) |
Generic (Proxy * t) |
Monoid (Proxy * s) |
Typeable (k -> *) (Proxy k) |
type Rep (Proxy k t) |

# Type representations

data TypeRep

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

Instances

Eq TypeRep |
Ord TypeRep |
Show TypeRep |
Typeable * TypeRep |

showsTypeRep :: TypeRep -> ShowS

data TyCon

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

Instances

Eq TyCon |
Ord TyCon |
Show TyCon |
Typeable * TyCon |

tyConString :: TyCon -> String

Deprecated: renamed to `tyConName`; `tyConModule` and `tyConPackage` are also available.

Observe string encoding of a type representation

tyConPackage :: TyCon -> String

Since: 4.5.0.0

tyConModule :: TyCon -> String

Since: 4.5.0.0

tyConName :: TyCon -> String

Since: 4.5.0.0

# Construction of type representations

mkTyCon3

Arguments

:: String | package name
-> String | module name
-> String | the name of the type constructor
-> TyCon | A unique `TyCon` object

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

     A==A' ^ B==B' ^ C==C' ==> mkTyCon A B C == mkTyCon A' B' C'

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

Applies a type constructor to a sequence of types

mkAppTy :: TypeRep -> TypeRep -> TypeRep

Adds a TypeRep argument to a TypeRep.

mkFunTy :: TypeRep -> TypeRep -> TypeRep

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

# Observation of type representations

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

Splits a type constructor application

funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep

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

Observe the type constructor of a type representation

typeRepArgs :: TypeRep -> [TypeRep]

Observe the argument types of a type representation