| 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
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
- class Typeable a
- typeRep ∷ ∀ proxy a. Typeable a ⇒ proxy a → TypeRep
- data a :~: b where
- typeOf ∷ ∀ a. Typeable a ⇒ a → TypeRep
- typeOf1 ∷ ∀ t a. Typeable t ⇒ t a → TypeRep
- typeOf2 ∷ ∀ t a b. Typeable t ⇒ t a b → TypeRep
- typeOf3 ∷ ∀ t a b c. Typeable t ⇒ t a b c → TypeRep
- typeOf4 ∷ ∀ t a b c d. Typeable t ⇒ t a b c d → TypeRep
- typeOf5 ∷ ∀ t a b c d e. Typeable t ⇒ t a b c d e → TypeRep
- typeOf6 ∷ ∀ t a b c d e f. Typeable t ⇒ t a b c d e f → TypeRep
- typeOf7 ∷ ∀ 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 ∷ ∀ a b. (Typeable a, Typeable b) ⇒ a → Maybe b
- eqT ∷ ∀ a b. (Typeable a, Typeable b) ⇒ Maybe (a :~: b)
- gcast ∷ ∀ a b c. (Typeable a, Typeable b) ⇒ c a → Maybe (c b)
- gcast1 ∷ ∀ c t t' a. (Typeable t, Typeable t') ⇒ c (t a) → Maybe (c (t' a))
- gcast2 ∷ ∀ 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
The class Typeable allows a concrete representation of a type to
be calculated.
Minimal complete definition
Instances
typeRep ∷ ∀ 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
Instances
For backwards compatibility
Type-safe cast
eqT ∷ ∀ a b. (Typeable a, Typeable b) ⇒ Maybe (a :~: b) Source
Extract a witness of equality of two types
Since: 4.7.0.0
gcast ∷ ∀ 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 ∷ ∀ c t t' a. (Typeable t, Typeable t') ⇒ c (t a) → Maybe (c (t' a)) Source
Cast over k1 -> k2
gcast2 ∷ ∀ 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
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
A concrete representation of a (monomorphic) type. TypeRep
supports reasonably efficient equality.
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
Since: 4.5.0.0
tyConModule ∷ TyCon → String Source
Since: 4.5.0.0
Construction of type representations
Arguments
| ∷ String | package name |
| → String | module name |
| → String | the name of the type constructor |
| → TyCon | A unique |
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 Source
Applies a type constructor to a sequence of types
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
typeRepTyCon ∷ TypeRep → TyCon Source
Observe the type constructor of a type representation
typeRepArgs ∷ TypeRep → [TypeRep] Source
Observe the argument types of a type representation