Data.TypeRep.Types.Basic

Representations for specific types

The reason for using symbol names ending with _t is that deriveRender uses everything that comes before _ when rendering the constructor.

Documentation

data BoolType a where

Constructors

Bool_t :: BoolType (Full Bool)

Instances

Render BoolType

VarArg BoolType

TypeEq BoolType t

PWitness Eq BoolType t

PWitness Integral BoolType t

PWitness Num BoolType t

PWitness Ord BoolType t

PWitness Show BoolType t

PWitness Any BoolType t

Witness Eq BoolType t

Witness Ord BoolType t

Witness Show BoolType t

Witness Any BoolType t

PWitness (Typeable *) BoolType t

Witness (Typeable *) BoolType t

data CharType a where

Constructors

Char_t :: CharType (Full Char)

Instances

Render CharType

VarArg CharType

TypeEq CharType t

PWitness Eq CharType t

PWitness Integral CharType t

PWitness Num CharType t

PWitness Ord CharType t

PWitness Show CharType t

PWitness Any CharType t

Witness Eq CharType t

Witness Ord CharType t

Witness Show CharType t

Witness Any CharType t

PWitness (Typeable *) CharType t

Witness (Typeable *) CharType t

data IntType a where

Constructors

Int_t :: IntType (Full Int)

Instances

Render IntType

VarArg IntType

TypeEq IntType t

PWitness Eq IntType t

PWitness Integral IntType t

PWitness Num IntType t

PWitness Ord IntType t

PWitness Show IntType t

PWitness Any IntType t

Witness Eq IntType t

Witness Integral IntType t

Witness Num IntType t

Witness Ord IntType t

Witness Show IntType t

Witness Any IntType t

PWitness (Typeable *) IntType t

Witness (Typeable *) IntType t

data FloatType a where

Constructors

Float_t :: FloatType (Full Float)

Instances

Render FloatType

VarArg FloatType

TypeEq FloatType t

PWitness Eq FloatType t

PWitness Integral FloatType t

PWitness Num FloatType t

PWitness Ord FloatType t

PWitness Show FloatType t

PWitness Any FloatType t

Witness Eq FloatType t

Witness Num FloatType t

Witness Ord FloatType t

Witness Show FloatType t

Witness Any FloatType t

PWitness (Typeable *) FloatType t

Witness (Typeable *) FloatType t

data DoubleType a where

Constructors

Double_t :: DoubleType (Full Double)

Instances

Render DoubleType

TypeEq DoubleType t

PWitness Eq DoubleType t

PWitness Integral DoubleType t

PWitness Num DoubleType t

PWitness Ord DoubleType t

PWitness Show DoubleType t

PWitness Any DoubleType t

Witness Eq DoubleType t

Witness Num DoubleType t

Witness Ord DoubleType t

Witness Show DoubleType t

Witness Any DoubleType t

PWitness (Typeable *) DoubleType t

Witness (Typeable *) DoubleType t

data ListType a where

Constructors

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

Instances

Render ListType

VarArg ListType

TypeEq t t => TypeEq ListType t

PWitness Eq t t => PWitness Eq ListType t

PWitness Integral ListType t

PWitness Num ListType t

PWitness Ord t t => PWitness Ord ListType t

PWitness Show t t => PWitness Show ListType t

PWitness Any ListType t

Witness Eq t t => Witness Eq ListType t

Witness Ord t t => Witness Ord ListType t

Witness Show t t => Witness Show ListType t

Witness Any ListType t

PWitness (Typeable *) t t => PWitness (Typeable *) ListType t

Witness (Typeable *) t t => Witness (Typeable *) ListType t

data FunType a where

Constructors

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

Instances

Render FunType

VarArg FunType

TypeEq t t => TypeEq FunType t

PWitness Eq FunType t

PWitness Integral FunType t

PWitness Num FunType t

PWitness Ord FunType t

PWitness Show FunType t

PWitness Any FunType t

Witness Any FunType t

PWitness (Typeable *) t t => PWitness (Typeable *) FunType t

Witness (Typeable *) t t => Witness (Typeable *) FunType t

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

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

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

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

doubleType :: (Syntactic a, DoubleType :<: Domain a, Internal a ~ Double) => a

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

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