Data.Typeable

base-4.9.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
- typeRepFingerprint :: TypeRep -> Fingerprint
- rnfTypeRep :: TypeRep -> ()
- showsTypeRep :: TypeRep -> ShowS
- data TyCon :: TYPE Lifted
- tyConFingerprint :: TyCon -> Fingerprint
- tyConString :: TyCon -> String
- tyConPackage :: TyCon -> String
- tyConModule :: TyCon -> String
- tyConName :: TyCon -> String
- rnfTyCon :: TyCon -> ()
- 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 Source

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

Minimal complete definition

typeRep#

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

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 Source

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) |
Methods id :: cat a a Source (.) :: cat b c -> cat a b -> cat a c Source
TestEquality k ((:~:) k a) |
Methods testEquality :: f a -> f b -> Maybe (((k :~: a) :~: a) b) Source
TestCoercion k ((:~:) k a) |
Methods testCoercion :: f a -> f b -> Maybe (Coercion (k :~: a) a b) Source
(~) k a b => Bounded ((:~:) k a b) |
Methods minBound :: (k :~: a) b Source maxBound :: (k :~: a) b Source
(~) k a b => Enum ((:~:) k a b) |
Methods succ :: (k :~: a) b -> (k :~: a) b Source pred :: (k :~: a) b -> (k :~: a) b Source toEnum :: Int -> (k :~: a) b Source fromEnum :: (k :~: a) b -> Int Source enumFrom :: (k :~: a) b -> [(k :~: a) b] Source enumFromThen :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] Source enumFromTo :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] Source enumFromThenTo :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] Source
Eq ((:~:) k a b) |
Methods (==) :: (k :~: a) b -> (k :~: a) b -> Bool Source (/=) :: (k :~: a) b -> (k :~: a) b -> Bool Source
((~) (TYPE Lifted) a b, Data a) => Data ((:~:) (TYPE Lifted) a b) |
Methods gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> (TYPE Lifted :~: a) b -> c ((TYPE Lifted :~: a) b) Source gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((TYPE Lifted :~: a) b) Source toConstr :: (TYPE Lifted :~: a) b -> Constr Source dataTypeOf :: (TYPE Lifted :~: a) b -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c ((TYPE Lifted :~: a) b)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((TYPE Lifted :~: a) b)) Source gmapT :: (forall c. Data c => c -> c) -> (TYPE Lifted :~: a) b -> (TYPE Lifted :~: a) b Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (TYPE Lifted :~: a) b -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (TYPE Lifted :~: a) b -> r Source gmapQ :: (forall d. Data d => d -> u) -> (TYPE Lifted :~: a) b -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> (TYPE Lifted :~: a) b -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b) Source
Ord ((:~:) k a b) |
Methods compare :: (k :~: a) b -> (k :~: a) b -> Ordering Source (<) :: (k :~: a) b -> (k :~: a) b -> Bool Source (<=) :: (k :~: a) b -> (k :~: a) b -> Bool Source (>) :: (k :~: a) b -> (k :~: a) b -> Bool Source (>=) :: (k :~: a) b -> (k :~: a) b -> Bool Source max :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b Source min :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b Source
(~) k a b => Read ((:~:) k a b) |
Methods readsPrec :: Int -> ReadS ((k :~: a) b) Source readList :: ReadS [(k :~: a) b] Source readPrec :: ReadPrec ((k :~: a) b) Source readListPrec :: ReadPrec [(k :~: a) b] Source
Show ((:~:) k a b) |
Methods showsPrec :: Int -> (k :~: a) b -> ShowS Source show :: (k :~: a) b -> String Source showList :: [(k :~: a) b] -> ShowS Source

# For backwards compatibility

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

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

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

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

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

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

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

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

type Typeable1 a = Typeable a Source

Deprecated: renamed to `Typeable`

type Typeable2 a = Typeable a Source

Deprecated: renamed to `Typeable`

type Typeable3 a = Typeable a Source

Deprecated: renamed to `Typeable`

type Typeable4 a = Typeable a Source

Deprecated: renamed to `Typeable`

type Typeable5 a = Typeable a Source

Deprecated: renamed to `Typeable`

type Typeable6 a = Typeable a Source

Deprecated: renamed to `Typeable`

type Typeable7 a = Typeable a Source

Deprecated: renamed to `Typeable`

# Type-safe cast

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

The type-safe cast operation

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

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) Source

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)) Source

Cast over `k1 -> k2`

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

Cast over `k1 -> k2 -> k3`

# A canonical proxy type

data Proxy t Source

A concrete, poly-kinded proxy type

Constructors

Proxy |

Instances

Monad (Proxy (TYPE Lifted)) |
Methods (>>=) :: Proxy (TYPE Lifted) a -> (a -> Proxy (TYPE Lifted) b) -> Proxy (TYPE Lifted) b Source (>>) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) b Source return :: a -> Proxy (TYPE Lifted) a Source fail :: String -> Proxy (TYPE Lifted) a Source
Functor (Proxy (TYPE Lifted)) |
Methods fmap :: (a -> b) -> Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b Source (<$) :: a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) a Source
Applicative (Proxy (TYPE Lifted)) |
Methods pure :: a -> Proxy (TYPE Lifted) a Source (<*>) :: Proxy (TYPE Lifted) (a -> b) -> Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b Source (*>) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) b Source (<*) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) a Source
Foldable (Proxy (TYPE Lifted)) |
Methods fold :: Monoid m => Proxy (TYPE Lifted) m -> m Source foldMap :: Monoid m => (a -> m) -> Proxy (TYPE Lifted) a -> m Source foldr :: (a -> b -> b) -> b -> Proxy (TYPE Lifted) a -> b Source foldr' :: (a -> b -> b) -> b -> Proxy (TYPE Lifted) a -> b Source foldl :: (b -> a -> b) -> b -> Proxy (TYPE Lifted) a -> b Source foldl' :: (b -> a -> b) -> b -> Proxy (TYPE Lifted) a -> b Source foldr1 :: (a -> a -> a) -> Proxy (TYPE Lifted) a -> a Source foldl1 :: (a -> a -> a) -> Proxy (TYPE Lifted) a -> a Source toList :: Proxy (TYPE Lifted) a -> [a] Source null :: Proxy (TYPE Lifted) a -> Bool Source length :: Proxy (TYPE Lifted) a -> Int Source elem :: Eq a => a -> Proxy (TYPE Lifted) a -> Bool Source maximum :: Ord a => Proxy (TYPE Lifted) a -> a Source minimum :: Ord a => Proxy (TYPE Lifted) a -> a Source sum :: Num a => Proxy (TYPE Lifted) a -> a Source product :: Num a => Proxy (TYPE Lifted) a -> a Source
Traversable (Proxy (TYPE Lifted)) |
Methods traverse :: Applicative f => (a -> f b) -> Proxy (TYPE Lifted) a -> f (Proxy (TYPE Lifted) b) Source sequenceA :: Applicative f => Proxy (TYPE Lifted) (f a) -> f (Proxy (TYPE Lifted) a) Source mapM :: Monad m => (a -> m b) -> Proxy (TYPE Lifted) a -> m (Proxy (TYPE Lifted) b) Source sequence :: Monad m => Proxy (TYPE Lifted) (m a) -> m (Proxy (TYPE Lifted) a) Source
Generic1 (Proxy *) |
Associated Types type Rep1 (Proxy * :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: Proxy * a -> Rep1 (Proxy *) a Source to1 :: Rep1 (Proxy *) a -> Proxy * a Source
Bounded (Proxy k s) |
Methods minBound :: Proxy k s Source maxBound :: Proxy k s Source
Enum (Proxy k s) |
Methods succ :: Proxy k s -> Proxy k s Source pred :: Proxy k s -> Proxy k s Source toEnum :: Int -> Proxy k s Source fromEnum :: Proxy k s -> Int Source enumFrom :: Proxy k s -> [Proxy k s] Source enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s] Source enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s] Source enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s] Source
Eq (Proxy k s) |
Methods (==) :: Proxy k s -> Proxy k s -> Bool Source (/=) :: Proxy k s -> Proxy k s -> Bool Source
Data t => Data (Proxy (TYPE Lifted) t) |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy (TYPE Lifted) t -> c (Proxy (TYPE Lifted) t) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy (TYPE Lifted) t) Source toConstr :: Proxy (TYPE Lifted) t -> Constr Source dataTypeOf :: Proxy (TYPE Lifted) t -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy (TYPE Lifted) t)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Proxy (TYPE Lifted) t)) Source gmapT :: (forall b. Data b => b -> b) -> Proxy (TYPE Lifted) t -> Proxy (TYPE Lifted) t Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy (TYPE Lifted) t -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy (TYPE Lifted) t -> r Source gmapQ :: (forall d. Data d => d -> u) -> Proxy (TYPE Lifted) t -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy (TYPE Lifted) t -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy (TYPE Lifted) t -> m (Proxy (TYPE Lifted) t) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy (TYPE Lifted) t -> m (Proxy (TYPE Lifted) t) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy (TYPE Lifted) t -> m (Proxy (TYPE Lifted) t) Source
Ord (Proxy k s) |
Methods compare :: Proxy k s -> Proxy k s -> Ordering Source (<) :: Proxy k s -> Proxy k s -> Bool Source (<=) :: Proxy k s -> Proxy k s -> Bool Source (>) :: Proxy k s -> Proxy k s -> Bool Source (>=) :: Proxy k s -> Proxy k s -> Bool Source max :: Proxy k s -> Proxy k s -> Proxy k s Source min :: Proxy k s -> Proxy k s -> Proxy k s Source
Read (Proxy k s) |
Methods readsPrec :: Int -> ReadS (Proxy k s) Source readList :: ReadS [Proxy k s] Source readPrec :: ReadPrec (Proxy k s) Source readListPrec :: ReadPrec [Proxy k s] Source
Show (Proxy k s) |
Methods showsPrec :: Int -> Proxy k s -> ShowS Source show :: Proxy k s -> String Source showList :: [Proxy k s] -> ShowS Source
Ix (Proxy k s) |
Methods range :: (Proxy k s, Proxy k s) -> [Proxy k s] Source index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int Source unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool Source rangeSize :: (Proxy k s, Proxy k s) -> Int Source unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int
Generic (Proxy k t) |
Associated Types type Rep (Proxy k t) :: * -> * Source Methods from :: Proxy k t -> Rep (Proxy k t) x Source to :: Rep (Proxy k t) x -> Proxy k t Source
Semigroup (Proxy k s) |
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s Source sconcat :: NonEmpty (Proxy k s) -> Proxy k s Source stimes :: Integral b => b -> Proxy k s -> Proxy k s Source
Monoid (Proxy k s) |
Methods mempty :: Proxy k s Source mappend :: Proxy k s -> Proxy k s -> Proxy k s Source mconcat :: [Proxy k s] -> Proxy k s Source
type Rep1 (Proxy k) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1) |
type Rep (Proxy k t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1) |

# Type representations

data TypeRep Source

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

Instances

Eq TypeRep |
Methods (==) :: TypeRep -> TypeRep -> Bool Source (/=) :: TypeRep -> TypeRep -> Bool Source
Ord TypeRep |
Methods compare :: TypeRep -> TypeRep -> Ordering Source (<) :: TypeRep -> TypeRep -> Bool Source (<=) :: TypeRep -> TypeRep -> Bool Source (>) :: TypeRep -> TypeRep -> Bool Source (>=) :: TypeRep -> TypeRep -> Bool Source max :: TypeRep -> TypeRep -> TypeRep Source min :: TypeRep -> TypeRep -> TypeRep Source
Show TypeRep |
Methods showsPrec :: Int -> TypeRep -> ShowS Source show :: TypeRep -> String Source showList :: [TypeRep] -> ShowS Source

typeRepFingerprint :: TypeRep -> Fingerprint Source

Observe the `Fingerprint` of a type representation

Since: 4.8.0.0

rnfTypeRep :: TypeRep -> () Source

Helper to fully evaluate `TypeRep` for use as `NFData(rnf)` implementation

Since: 4.8.0.0

showsTypeRep :: TypeRep -> ShowS Source

data TyCon :: TYPE Lifted Source

Instances

Eq TyCon |
Methods (==) :: TyCon -> TyCon -> Bool Source (/=) :: TyCon -> TyCon -> Bool Source
Ord TyCon |
Methods compare :: TyCon -> TyCon -> Ordering Source (<) :: TyCon -> TyCon -> Bool Source (<=) :: TyCon -> TyCon -> Bool Source (>) :: TyCon -> TyCon -> Bool Source (>=) :: TyCon -> TyCon -> Bool Source max :: TyCon -> TyCon -> TyCon Source min :: TyCon -> TyCon -> TyCon Source
Show TyCon |
Methods showsPrec :: Int -> TyCon -> ShowS Source show :: TyCon -> String Source showList :: [TyCon] -> ShowS Source

tyConFingerprint :: TyCon -> Fingerprint Source

tyConString :: TyCon -> String Source

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

Observe string encoding of a type representation

tyConPackage :: TyCon -> String Source

tyConModule :: TyCon -> String Source

tyConName :: TyCon -> String Source

rnfTyCon :: TyCon -> () Source

# Construction of type representations

mkTyCon3 Source

Arguments

:: String | package name
-> String | module name
-> String | the name of the type constructor
-> TyCon | A unique `TyCon` object Used when the strings are dynamically allocated, eg from binary deserialisation

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

Applies a kind-monomorphic 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. Note that if the type construcotr is polymorphic, this will not return the kinds that were used. See `splitPolyTyConApp` if you need all parts.

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