base-4.9.0.0: Basic libraries

Copyright(c) The University of Glasgow, CWI 2001--2004
LicenseBSD-style (see the file libraries/base/LICENSE)
Maintainerlibraries@haskell.org
Stabilityexperimental
Portabilityportable
Safe HaskellTrustworthy
LanguageHaskell2010

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

Synopsis

The Typeable class

class Typeable a

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

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) 

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

TestEquality k ((:~:) k a) 

Methods

testEquality :: f a -> f b -> Maybe (((k :~: a) :~: a) b)

TestCoercion k ((:~:) k a) 

Methods

testCoercion :: f a -> f b -> Maybe (Coercion (k :~: a) a b)

(~) k a b => Bounded ((:~:) k a b) 

Methods

minBound :: (k :~: a) b

maxBound :: (k :~: a) b

(~) k a b => Enum ((:~:) k a b) 

Methods

succ :: (k :~: a) b -> (k :~: a) b

pred :: (k :~: a) b -> (k :~: a) b

toEnum :: Int -> (k :~: a) b

fromEnum :: (k :~: a) b -> Int

enumFrom :: (k :~: a) b -> [(k :~: a) b]

enumFromThen :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b]

enumFromTo :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b]

enumFromThenTo :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b -> [(k :~: a) b]

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)

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((TYPE Lifted :~: a) b)

toConstr :: (TYPE Lifted :~: a) b -> Constr

dataTypeOf :: (TYPE Lifted :~: a) b -> DataType

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c ((TYPE Lifted :~: a) b))

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

gmapT :: (forall c. Data c => c -> c) -> (TYPE Lifted :~: a) b -> (TYPE Lifted :~: a) b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (TYPE Lifted :~: a) b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (TYPE Lifted :~: a) b -> r

gmapQ :: (forall d. Data d => d -> u) -> (TYPE Lifted :~: a) b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (TYPE Lifted :~: a) b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b)

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)

readList :: ReadS [(k :~: a) b]

readPrec :: ReadPrec ((k :~: a) b)

readListPrec :: ReadPrec [(k :~: a) b]

Show ((:~:) k a b) 

Methods

showsPrec :: Int -> (k :~: a) b -> ShowS

show :: (k :~: a) b -> String

showList :: [(k :~: a) b] -> ShowS

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 (TYPE Lifted)) 

Methods

(>>=) :: Proxy (TYPE Lifted) a -> (a -> Proxy (TYPE Lifted) b) -> Proxy (TYPE Lifted) b

(>>) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) b

return :: a -> Proxy (TYPE Lifted) a

fail :: String -> Proxy (TYPE Lifted) a

Functor (Proxy (TYPE Lifted)) 

Methods

fmap :: (a -> b) -> Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b

(<$) :: a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) a

Applicative (Proxy (TYPE Lifted)) 

Methods

pure :: a -> Proxy (TYPE Lifted) a

(<*>) :: Proxy (TYPE Lifted) (a -> b) -> Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b

(*>) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) b

(<*) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) a

Foldable (Proxy (TYPE Lifted)) 

Methods

fold :: Monoid m => Proxy (TYPE Lifted) m -> m

foldMap :: Monoid m => (a -> m) -> Proxy (TYPE Lifted) a -> m

foldr :: (a -> b -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldr' :: (a -> b -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldl :: (b -> a -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldl' :: (b -> a -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldr1 :: (a -> a -> a) -> Proxy (TYPE Lifted) a -> a

foldl1 :: (a -> a -> a) -> Proxy (TYPE Lifted) a -> a

toList :: Proxy (TYPE Lifted) a -> [a]

null :: Proxy (TYPE Lifted) a -> Bool

length :: Proxy (TYPE Lifted) a -> Int

elem :: Eq a => a -> Proxy (TYPE Lifted) a -> Bool

maximum :: Ord a => Proxy (TYPE Lifted) a -> a

minimum :: Ord a => Proxy (TYPE Lifted) a -> a

sum :: Num a => Proxy (TYPE Lifted) a -> a

product :: Num a => Proxy (TYPE Lifted) a -> a

Traversable (Proxy (TYPE Lifted)) 

Methods

traverse :: Applicative f => (a -> f b) -> Proxy (TYPE Lifted) a -> f (Proxy (TYPE Lifted) b)

sequenceA :: Applicative f => Proxy (TYPE Lifted) (f a) -> f (Proxy (TYPE Lifted) a)

mapM :: Monad m => (a -> m b) -> Proxy (TYPE Lifted) a -> m (Proxy (TYPE Lifted) b)

sequence :: Monad m => Proxy (TYPE Lifted) (m a) -> m (Proxy (TYPE Lifted) a)

Generic1 (Proxy *) 

Associated Types

type Rep1 (Proxy * :: * -> TYPE Lifted) :: * -> *

Methods

from1 :: Proxy * a -> Rep1 (Proxy *) a

to1 :: Rep1 (Proxy *) a -> Proxy * a

Bounded (Proxy k s) 

Methods

minBound :: Proxy k s

maxBound :: Proxy k s

Enum (Proxy k s) 

Methods

succ :: Proxy k s -> Proxy k s

pred :: Proxy k s -> Proxy k s

toEnum :: Int -> Proxy k s

fromEnum :: Proxy k s -> Int

enumFrom :: Proxy k s -> [Proxy k s]

enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s]

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)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy (TYPE Lifted) t)

toConstr :: Proxy (TYPE Lifted) t -> Constr

dataTypeOf :: Proxy (TYPE Lifted) t -> DataType

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy (TYPE Lifted) t))

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

gmapT :: (forall b. Data b => b -> b) -> Proxy (TYPE Lifted) t -> Proxy (TYPE Lifted) t

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy (TYPE Lifted) t -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy (TYPE Lifted) t -> r

gmapQ :: (forall d. Data d => d -> u) -> Proxy (TYPE Lifted) t -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy (TYPE Lifted) t -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy (TYPE Lifted) t -> m (Proxy (TYPE Lifted) t)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy (TYPE Lifted) t -> m (Proxy (TYPE Lifted) t)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy (TYPE Lifted) t -> m (Proxy (TYPE Lifted) t)

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) 
Show (Proxy k s) 

Methods

showsPrec :: Int -> Proxy k s -> ShowS

show :: Proxy k s -> String

showList :: [Proxy k s] -> ShowS

Ix (Proxy k s) 

Methods

range :: (Proxy k s, Proxy k s) -> [Proxy k s]

index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool

rangeSize :: (Proxy k s, Proxy k s) -> Int

unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int

Generic (Proxy k t) 

Associated Types

type Rep (Proxy k t) :: * -> *

Methods

from :: Proxy k t -> Rep (Proxy k t) x

to :: Rep (Proxy k t) x -> Proxy k t

Semigroup (Proxy k s) 

Methods

(<>) :: Proxy k s -> Proxy k s -> Proxy k s

sconcat :: NonEmpty (Proxy k s) -> Proxy k s

stimes :: Integral b => b -> Proxy k s -> Proxy k s

Monoid (Proxy k s) 

Methods

mempty :: Proxy k s

mappend :: Proxy k s -> Proxy k s -> Proxy k s

mconcat :: [Proxy k s] -> Proxy k s

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

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

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

tyConString :: TyCon -> String

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

Observe string encoding of a type representation

rnfTyCon :: TyCon -> ()

Construction of type representations

mkTyCon3

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

Applies a kind-monomorphic 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. 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

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