Haskell 8
Haskell 8
  • 请登录查看
字典 我要纠错

Data.Typeable

Data.Typeable

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

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

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

((~) * a b, Data a) => Data ((:~:) * a b)

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> (* :~: a) b -> c ((* :~: a) b) Source

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

toConstr :: (* :~: a) b -> Constr Source

dataTypeOf :: (* :~: a) b -> DataType Source

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

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :~: a) b)) Source

gmapT :: (forall c. Data c => c -> c) -> (* :~: a) b -> (* :~: a) b Source

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

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

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

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

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

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

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: 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 *)

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b Source

(>>) :: Proxy * a -> Proxy * b -> Proxy * b Source

return :: a -> Proxy * a Source

fail :: String -> Proxy * a Source

Functor (Proxy *)

Methods

fmap :: (a -> b) -> Proxy * a -> Proxy * b Source

(<$) :: a -> Proxy * b -> Proxy * a Source

Applicative (Proxy *)

Methods

pure :: a -> Proxy * a Source

(<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b Source

(*>) :: Proxy * a -> Proxy * b -> Proxy * b Source

(<*) :: Proxy * a -> Proxy * b -> Proxy * a Source

Foldable (Proxy *)

Methods

fold :: Monoid m => Proxy * m -> m Source

foldMap :: Monoid m => (a -> m) -> Proxy * a -> m Source

foldr :: (a -> b -> b) -> b -> Proxy * a -> b Source

foldr' :: (a -> b -> b) -> b -> Proxy * a -> b Source

foldl :: (b -> a -> b) -> b -> Proxy * a -> b Source

foldl' :: (b -> a -> b) -> b -> Proxy * a -> b Source

foldr1 :: (a -> a -> a) -> Proxy * a -> a Source

foldl1 :: (a -> a -> a) -> Proxy * a -> a Source

toList :: Proxy * a -> [a] Source

null :: Proxy * a -> Bool Source

length :: Proxy * a -> Int Source

elem :: Eq a => a -> Proxy * a -> Bool Source

maximum :: Ord a => Proxy * a -> a Source

minimum :: Ord a => Proxy * a -> a Source

sum :: Num a => Proxy * a -> a Source

product :: Num a => Proxy * a -> a Source

Traversable (Proxy *)

Methods

traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) Source

sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) Source

mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) Source

sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) Source

Generic1 (Proxy *)

Associated Types

type Rep1 (Proxy * :: * -> *) :: * -> * Source

Methods

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

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

MonadPlus (Proxy *)

Methods

mzero :: Proxy * a Source

mplus :: Proxy * a -> Proxy * a -> Proxy * a Source

Alternative (Proxy *)

Methods

empty :: Proxy * a Source

(<|>) :: Proxy * a -> Proxy * a -> Proxy * a Source

some :: Proxy * a -> Proxy * [a] Source

many :: Proxy * a -> Proxy * [a] Source

MonadZip (Proxy *)

Methods

mzip :: Proxy * a -> Proxy * b -> Proxy * (a, b) Source

mzipWith :: (a -> b -> c) -> Proxy * a -> Proxy * b -> Proxy * c Source

munzip :: Proxy * (a, b) -> (Proxy * a, Proxy * b) Source

Show1 (Proxy *)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy * a -> ShowS Source

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy * a] -> ShowS Source

Read1 (Proxy *)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy * a) Source

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy * a] Source

Ord1 (Proxy *)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Proxy * a -> Proxy * b -> Ordering Source

Eq1 (Proxy *)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Proxy * a -> Proxy * b -> Bool 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 * t)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy * t -> c (Proxy * t) Source

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

toConstr :: Proxy * t -> Constr Source

dataTypeOf :: Proxy * t -> DataType Source

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

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Proxy * t)) Source

gmapT :: (forall b. Data b => b -> b) -> Proxy * t -> Proxy * t Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r Source

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy * t -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * 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)
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 *)
type Rep1 (Proxy *) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)
type Rep (Proxy k t)
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

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 :: * Source

Instances

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

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.0.1/docs/html/libraries/base-4.9.0.0/Data-Typeable.html

在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号

意见反馈
返回顶部