open-typerep-0.3.3: 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) Source 
Syntactic (TypeRep t a) Source 
type Internal (TypeRep t a) = a Source 
type Domain (TypeRep t a) = t Source 

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

Reification of type a in a type universe t

class Render t => TypeEq t u where Source

Equality on type representations

Methods

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

Instances

typeEq :: (TypeEq t t, MonadError String m) => TypeRep t a -> TypeRep t b -> m (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 ShowClass p where Source

Show the name of type classes

Methods

showClass :: Proxy p -> String Source

Show the name of a type class

Instances

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 (ShowClass p, Render t) => 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 -> Either String (Dict (p (DenResult sig))) Source

Instances

PWitness Eq FunType t Source 
PWitness Eq t t => PWitness Eq ListType t Source 
PWitness Eq FloatType t Source 
PWitness Eq IntType t Source 
PWitness Eq CharType t Source 
PWitness Eq BoolType t Source 
PWitness Integral FunType t Source 
PWitness Integral ListType t Source 
PWitness Integral FloatType t Source 
PWitness Integral IntType t Source 
PWitness Integral CharType t Source 
PWitness Integral BoolType t Source 
PWitness Num FunType t Source 
PWitness Num ListType t Source 
PWitness Num FloatType t Source 
PWitness Num IntType t Source 
PWitness Num CharType t Source 
PWitness Num BoolType t Source 
PWitness Ord FunType t Source 
PWitness Ord t t => PWitness Ord ListType t Source 
PWitness Ord FloatType t Source 
PWitness Ord IntType t Source 
PWitness Ord CharType t Source 
PWitness Ord BoolType t Source 
PWitness Show FunType t Source 
PWitness Show t t => PWitness Show ListType t Source 
PWitness Show FloatType t Source 
PWitness Show IntType t Source 
PWitness Show CharType t Source 
PWitness Show BoolType t Source 
PWitness Any FunType t Source 
PWitness Any ListType t Source 
PWitness Any FloatType t Source 
PWitness Any IntType t Source 
PWitness Any CharType t Source 
PWitness Any BoolType t Source 
(PWitness p t1 t, PWitness p t2 t) => PWitness p ((:+:) t1 t2) t Source 
((:<:) FunType t, PWitness (Typeable t) t t) => PWitness (Typeable t) FunType t Source 
((:<:) ListType t, PWitness (Typeable t) t t) => PWitness (Typeable t) ListType t Source 
(:<:) FloatType t => PWitness (Typeable t) FloatType t Source 
(:<:) IntType t => PWitness (Typeable t) IntType t Source 
(:<:) CharType t => PWitness (Typeable t) CharType t Source 
(:<:) BoolType t => PWitness (Typeable t) BoolType t Source 

pwitSymDefault :: Witness p t u => t sig -> Args (AST u) sig -> Either String (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 m a. (PWitness p t t, MonadError String m) => Proxy p -> TypeRep t a -> m (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 -> Either String 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 -> Either String (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) Source 
Witness Show t t => Show (Dynamic t) Source 

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

fromDyn :: forall t a. (Typeable t a, TypeEq t t) => Dynamic t -> Either String 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 -> Either String (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 -> Either String Integer Source