base-4.8.2.0: Basic libraries

Copyright | (c) The University of Glasgow, CWI 2001--2011
License | BSD-style (see the file libraries/base/LICENSE)
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Typeable.Internal

Description

The representations of the types TyCon and TypeRep, and the function mkTyCon which is used by derived instances of Typeable to construct a TyCon.

Synopsis

- data Proxy t = Proxy
- data TypeRep = TypeRep !Fingerprint TyCon [KindRep] [TypeRep]
- type KindRep = TypeRep
- data Fingerprint = Fingerprint !Word64 !Word64
- 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
- data TyCon = TyCon {
  - tyConFingerprint :: !Fingerprint
  - tyConPackage :: String
  - tyConModule :: String
  - tyConName :: String
  }
- typeRep :: forall proxy a. Typeable a => proxy a -> TypeRep
- mkTyCon :: Word# -> Word# -> String -> String -> String -> TyCon
- mkTyCon3 :: String -> String -> String -> TyCon
- mkTyConApp :: TyCon -> [TypeRep] -> TypeRep
- mkPolyTyConApp :: TyCon -> [KindRep] -> [TypeRep] -> TypeRep
- mkAppTy :: TypeRep -> TypeRep -> TypeRep
- typeRepTyCon :: TypeRep -> TyCon
- class Typeable a where
  - typeRep# :: Proxy# a -> TypeRep
- mkFunTy :: TypeRep -> TypeRep -> TypeRep
- splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
- splitPolyTyConApp :: TypeRep -> (TyCon, [KindRep], [TypeRep])
- funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
- typeRepArgs :: TypeRep -> [TypeRep]
- typeRepFingerprint :: TypeRep -> Fingerprint
- rnfTypeRep :: TypeRep -> ()
- showsTypeRep :: TypeRep -> ShowS
- tyConString :: TyCon -> String
- rnfTyCon :: TyCon -> ()
- listTc :: TyCon
- funTc :: TyCon
- typeRepKinds :: TypeRep -> [KindRep]
- typeLitTypeRep :: String -> TypeRep

# Documentation

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 k s) |
type Rep (Proxy k t) |

data TypeRep

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

Constructors

TypeRep !Fingerprint TyCon [KindRep] [TypeRep] |

Instances

Eq TypeRep |
Ord TypeRep |
Show TypeRep |

type KindRep = TypeRep

data Fingerprint

Constructors

Fingerprint !Word64 !Word64 |

Instances

Eq Fingerprint |
Ord Fingerprint |
Show Fingerprint |
Storable Fingerprint |

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`

data TyCon

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

Constructors

TyCon |

Fields

tyConFingerprint :: !Fingerprint

  Since: 4.8.0.0

tyConPackage :: String

  Since: 4.5.0.0

tyConModule :: String

  Since: 4.5.0.0

tyConName :: String

  Since: 4.5.0.0

Instances

Eq TyCon |
Ord TyCon |
Show TyCon |

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

mkTyCon :: Word# -> Word# -> String -> String -> String -> TyCon

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 monomorphic type constructor to a sequence of types

mkPolyTyConApp :: TyCon -> [KindRep] -> [TypeRep] -> TypeRep

Applies a polymorhic type constructor to a sequence of kinds and types

mkAppTy :: TypeRep -> TypeRep -> TypeRep

Adds a TypeRep argument to a TypeRep.

typeRepTyCon :: TypeRep -> TyCon

Observe the type constructor of a type representation

class Typeable a where

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

Methods

typeRep# :: Proxy# a -> TypeRep

mkFunTy :: TypeRep -> TypeRep -> TypeRep

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

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

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.

splitPolyTyConApp :: TypeRep -> (TyCon, [KindRep], [TypeRep])

Split 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`.

typeRepArgs :: TypeRep -> [TypeRep]

Observe the argument types of a type representation

typeRepFingerprint :: TypeRep -> Fingerprint

Observe the `Fingerprint` of a type representation

Since: 4.8.0.0

rnfTypeRep :: TypeRep -> ()

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

Since: 4.8.0.0

showsTypeRep :: TypeRep -> ShowS

tyConString :: TyCon -> String

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

Observe string encoding of a type representation

rnfTyCon :: TyCon -> ()

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

Since: 4.8.0.0

listTc :: TyCon

funTc :: TyCon

typeRepKinds :: TypeRep -> [KindRep]

Observe the argument kinds of a type representation

typeLitTypeRep :: String -> TypeRep

An internal function, to make representations for type literals.