open-typerep-0.2: Open type representations and dynamic types

Safe HaskellNone
LanguageHaskell2010

Data.TypeRep.Internal

Contents

Description

Open type representations and dynamic types

Synopsis

Type representations

type TR = AST Source

Full-indexed type representation

class Typeable t a where Source

This class provides reification of type a in a universe t. Typeable t a means that a is in the type universe represented by t.

Methods

typeRep' :: TR t (Full a) Source

Instances

newtype TypeRep t a Source

Representation of type a in a type universe t

This type can also be seen as a witness that a is a member of t (i.e. Typeable t a); see witTypeable.

Constructors

TypeRep 

Fields

unTypeRep :: TR t (Full a)
 

Instances

Render t => Show (TypeRep t a) 
Syntactic (TypeRep t a) 
type Internal (TypeRep t a) = a 
type Domain (TypeRep t a) = t 

typeRep :: Typeable t a => TypeRep t a Source

Reification of type a in a type universe t

class TypeEq t u where Source

Equality on type representations

Methods

typeEqSym :: (t sig1, Args (AST u) sig1) -> (t sig2, Args (AST u) sig2) -> Maybe (Dict (DenResult sig1 ~ DenResult sig2)) Source

Instances

TypeEq Empty t 
TypeEq t t => TypeEq FunType t 
TypeEq t t => TypeEq ListType t 
TypeEq FloatType t 
TypeEq IntType t 
TypeEq CharType t 
TypeEq BoolType t 
TypeEq t t => TypeEq (AST t) t 
(TypeEq t1 t, TypeEq t2 t) => TypeEq ((:+:) t1 t2) t 

typeEq :: forall t a b. TypeEq t t => TypeRep t a -> TypeRep t b -> Maybe (Dict (a ~ b)) Source

Equality on type representations

matchCon :: TypeRep t c -> [E (TypeRep t)] Source

Type constructor matching. This function makes it possible to match on type representations without dealing with the underlying AST representation.

For example, to check that a TypeRep represents the type a -> Int for some a:

is_atoi :: (TypeEq t t, IntType :<: t) => TypeRep t a -> Bool
is_atoi t
    | [E ta, E tb] <- matchCon t
    , Just _       <- typeEq ta intType = True
    | otherwise                         = False

matchConM :: Monad m => TypeRep t c -> m [E (TypeRep t)] Source

Monadic version of matchCon

matchConM = return . matchCon

matchConM is convenient when matching types in a monad, e.g.:

do ...
   [E ta, E tb] <- matchConM t
   Dict         <- typeEq ta tb
   ...

class Witness p t u where Source

Witness a type constraint for a reified type

Methods

witSym :: t sig -> Args (AST u) sig -> Dict (p (DenResult sig)) Source

Instances

class PWitness p t u where Source

Partially witness a type constraint for a reified type

Minimal complete definition

Nothing

Methods

pwitSym :: t sig -> Args (AST u) sig -> Maybe (Dict (p (DenResult sig))) Source

Instances

pwitSymDefault :: Witness p t u => t sig -> Args (AST u) sig -> Maybe (Dict (p (DenResult sig))) Source

Default implementation of pwitSym for types that have a Witness instance

wit :: forall p t a. Witness p t t => Proxy p -> TypeRep t a -> Dict (p a) Source

Witness a type constraint for a reified type

pwit :: forall p t a. PWitness p t t => Proxy p -> TypeRep t a -> Maybe (Dict (p a)) Source

Partially witness a type constraint for a reified type

Dynamic types

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

Safe cast (does not use unsafeCoerce)

gcast :: forall t a b c. (Typeable t a, Typeable t b, TypeEq t t) => Proxy t -> c a -> Maybe (c b) Source

Safe generalized cast (does not use unsafeCoerce)

data Dynamic t where Source

Dynamic type parameterized on a type universe

Constructors

Dyn :: TypeRep t a -> a -> Dynamic t 

Instances

(TypeEq t t, Witness Eq t t) => Eq (Dynamic t) 
Witness Show t t => Show (Dynamic t) 

toDyn :: Typeable t a => a -> Dynamic t Source

fromDyn :: forall t a. (Typeable t a, TypeEq t t) => Dynamic t -> Maybe a Source

Specific types/classes

class Any a Source

The universal class

Instances

witTypeable :: Witness (Typeable t) t t => TypeRep t a -> Dict (Typeable t a) Source

Witness a Typeable constraint for a reified type

pwitTypeable :: PWitness (Typeable t) t t => TypeRep t a -> Maybe (Dict (Typeable t a)) Source

Partially witness a Typeable constraint for a reified type

pAny :: Proxy Any Source

pEq :: Proxy Eq Source

pOrd :: Proxy Ord Source

pShow :: Proxy Show Source

pNum :: Proxy Num Source

pIntegral :: Proxy Integral Source

data BoolType a where Source

Constructors

BoolType :: BoolType (Full Bool) 

Instances

data CharType a where Source

Constructors

CharType :: CharType (Full Char) 

Instances

data IntType a where Source

Constructors

IntType :: IntType (Full Int) 

Instances

data FloatType a where Source

Constructors

FloatType :: FloatType (Full Float) 

Instances

data ListType a where Source

Constructors

ListType :: ListType (a :-> Full [a]) 

Instances

data FunType a where Source

Constructors

FunType :: FunType (a :-> (b :-> Full (a -> b))) 

Instances

boolType :: (Syntactic a, BoolType :<: Domain a, Internal a ~ Bool) => a Source

charType :: (Syntactic a, CharType :<: Domain a, Internal a ~ Char) => a Source

intType :: (Syntactic a, IntType :<: Domain a, Internal a ~ Int) => a Source

floatType :: (Syntactic a, FloatType :<: Domain a, Internal a ~ Float) => a Source

listType :: (Syntactic list, Syntactic elem, Domain list ~ Domain elem, ListType :<: Domain list, Internal list ~ [Internal elem], elem ~ c e, list ~ c l) => elem -> list Source

funType :: (Syntactic fun, Syntactic a, Syntactic b, Domain fun ~ Domain a, Domain fun ~ Domain b, FunType :<: Domain fun, Internal fun ~ (Internal a -> Internal b), a ~ c x, b ~ c y, fun ~ c z) => a -> b -> fun Source

dynToInteger :: PWitness Integral t t => Dynamic t -> Maybe Integer Source