DDC.Source.Tetra.Prim

Definitions of Source Tetra primitive names and operators.

Primitive Types

data PrimType

Primitive types.

Constructors

PrimTypeSoCon !SoCon

Primitive sort constructors.

PrimTypeKiCon !KiCon

Primitive kind constructors.

PrimTypeTwCon !TwCon

Primitive witness type constructors.

PrimTypeTcCon !TcCon

Other type constructors at the spec level.

PrimTypeTyCon !PrimTyCon

Primitive machine type constructors.

PrimTypeTyConTetra !PrimTyConTetra

Primtiive type constructors specific to the Tetra fragment.

Instances

Eq PrimType

Methods

(==) :: PrimType -> PrimType -> Bool

(/=) :: PrimType -> PrimType -> Bool

Ord PrimType

Methods

compare :: PrimType -> PrimType -> Ordering

(<) :: PrimType -> PrimType -> Bool

(<=) :: PrimType -> PrimType -> Bool

(>) :: PrimType -> PrimType -> Bool

(>=) :: PrimType -> PrimType -> Bool

max :: PrimType -> PrimType -> PrimType

min :: PrimType -> PrimType -> PrimType

Show PrimType

Methods

showsPrec :: Int -> PrimType -> ShowS

show :: PrimType -> String

showList :: [PrimType] -> ShowS

readPrimType :: String -> Maybe PrimType

Read the name of a primitive type.

Primitive machine type constructors.

data PrimTyCon :: *

Primitive type constructors.

Constructors

PrimTyConVoid

Void# the Void type has no values.

PrimTyConBool

Bool# unboxed booleans.

PrimTyConNat

Nat# natural numbers. Enough precision to count every object in the heap, but NOT necessearily enough precision to count every byte of memory.

PrimTyConInt

Int# signed integers. Enough precision to count every object in the heap, but NOT necessearily enough precision to count every byte of memory. If N is the total number of objects that can exist in the heap, then the range of Int# is at least (-N .. +N) inclusive.

PrimTyConSize

Size# unsigned sizes. Enough precision to count every addressable bytes of memory.

PrimTyConWord Int

WordN# machine words of the given width.

PrimTyConFloat Int

FloatN# floating point numbers of the given width.

PrimTyConVec Int

VecN# a packed vector of N values. This is intended to have kind (Data -> Data), so we use concrete vector types like Vec4.

PrimTyConAddr

Addr# a relative or absolute machine address. Enough precision to count every byte of memory. Unlike pointers below, an absolute Addr# need not refer to memory owned by the current process.

PrimTyConPtr

Ptr# like Addr#, but with a region and element type annotation. In particular, a value of a type like (Ptr) must be at least 4-byte aligned and point to memory owned by the current process.

PrimTyConTextLit

TextLit# type of a text literal, which is represented as a pointer to the literal data in static memory.

PrimTyConTag

Tag# data constructor tags. Enough precision to count every possible alternative of an enumerated type.

Instances

Eq PrimTyCon

Methods

(==) :: PrimTyCon -> PrimTyCon -> Bool

(/=) :: PrimTyCon -> PrimTyCon -> Bool

Ord PrimTyCon

Methods

compare :: PrimTyCon -> PrimTyCon -> Ordering

(<) :: PrimTyCon -> PrimTyCon -> Bool

(<=) :: PrimTyCon -> PrimTyCon -> Bool

(>) :: PrimTyCon -> PrimTyCon -> Bool

(>=) :: PrimTyCon -> PrimTyCon -> Bool

max :: PrimTyCon -> PrimTyCon -> PrimTyCon

min :: PrimTyCon -> PrimTyCon -> PrimTyCon

Show PrimTyCon

Methods

showsPrec :: Int -> PrimTyCon -> ShowS

show :: PrimTyCon -> String

showList :: [PrimTyCon] -> ShowS

Pretty PrimTyCon

Associated Types

data PrettyMode PrimTyCon :: *

Methods

pprDefaultMode :: PrettyMode PrimTyCon

ppr :: PrimTyCon -> Doc

pprPrec :: Int -> PrimTyCon -> Doc

pprModePrec :: PrettyMode PrimTyCon -> Int -> PrimTyCon -> Doc

NFData PrimTyCon

Methods

rnf :: PrimTyCon -> ()

kindPrimTyCon :: PrimType ~ GTPrim l => PrimTyCon -> GType l

Yield the kind of a type constructor.

pattern KData :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Representation of the Data kind.

pattern KRegion :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Representation of the Region kind.

pattern KEffect :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Representation of the Effect kind.

pattern TImpl :: forall t. (~#) * * (GTPrim t) PrimType => GType t -> GType t -> GType t

Representation of an implication type.

pattern TSusp :: forall t. (~#) * * (GTPrim t) PrimType => GType t -> GType t -> GType t

Representation of a suspension type.

pattern TRead :: forall t. (~#) * * (GTPrim t) PrimType => GType t -> GType t

Representation of a read effect.

pattern TWrite :: forall t. (~#) * * (GTPrim t) PrimType => GType t -> GType t

Representation of a write effect.

pattern TAlloc :: forall t. (~#) * * (GTPrim t) PrimType => GType t -> GType t

Representation of a alloc effect.

pattern TBool :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Primitive Bool type.

pattern TNat :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Primitive Nat type.

pattern TInt :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Primitive Int type.

pattern TSize :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Primitive Size type.

pattern TWord :: forall t. (~#) * * (GTPrim t) PrimType => Int -> GType t

Primitive WordN type of the given width.

pattern TFloat :: forall t. (~#) * * (GTPrim t) PrimType => Int -> GType t

Primitive FloatN type of the given width.

pattern TTextLit :: forall t. (~#) * * (GTPrim t) PrimType => GType t

Primitive TextLit type.

Primitive tetra type constructors.

data PrimTyConTetra

Primitive type constructors specific to the Tetra language fragment.

Constructors

PrimTyConTetraTuple !Int

TupleN#. Tuples.

PrimTyConTetraVector

Vector#. Vectors.

PrimTyConTetraF

F#. Reified function values.

PrimTyConTetraC

C#. Reified function closures.

PrimTyConTetraU

U#. Explicitly unboxed values.

Instances

Eq PrimTyConTetra

Methods

(==) :: PrimTyConTetra -> PrimTyConTetra -> Bool

(/=) :: PrimTyConTetra -> PrimTyConTetra -> Bool

Ord PrimTyConTetra

Methods

compare :: PrimTyConTetra -> PrimTyConTetra -> Ordering

(<) :: PrimTyConTetra -> PrimTyConTetra -> Bool

(<=) :: PrimTyConTetra -> PrimTyConTetra -> Bool

(>) :: PrimTyConTetra -> PrimTyConTetra -> Bool

(>=) :: PrimTyConTetra -> PrimTyConTetra -> Bool

max :: PrimTyConTetra -> PrimTyConTetra -> PrimTyConTetra

min :: PrimTyConTetra -> PrimTyConTetra -> PrimTyConTetra

Show PrimTyConTetra

Methods

showsPrec :: Int -> PrimTyConTetra -> ShowS

show :: PrimTyConTetra -> String

showList :: [PrimTyConTetra] -> ShowS

kindPrimTyConTetra :: (~#) * * (GTPrim l) PrimType => PrimTyConTetra -> GType l

Take the kind of a baked-in data constructor.

Primitive values

data PrimVal

Primitive values.

Constructors

PrimValLit !PrimLit

Primitive literals.

PrimValArith !PrimArith

Primitive arithmetic operators.

PrimValCast !PrimCast

Primitive numeric casting operators.

PrimValError !OpError

Primitive error handling.

PrimValVector !OpVector

Primitive vector operators.

PrimValFun !OpFun

Primitive function operators.

Instances

Eq PrimVal

Methods

(==) :: PrimVal -> PrimVal -> Bool

(/=) :: PrimVal -> PrimVal -> Bool

Ord PrimVal

Methods

compare :: PrimVal -> PrimVal -> Ordering

(<) :: PrimVal -> PrimVal -> Bool

(<=) :: PrimVal -> PrimVal -> Bool

(>) :: PrimVal -> PrimVal -> Bool

(>=) :: PrimVal -> PrimVal -> Bool

max :: PrimVal -> PrimVal -> PrimVal

min :: PrimVal -> PrimVal -> PrimVal

Show PrimVal

Methods

showsPrec :: Int -> PrimVal -> ShowS

show :: PrimVal -> String

showList :: [PrimVal] -> ShowS

readPrimVal :: String -> Maybe PrimVal

Read the name of a primtive value.

Primitive arithmetic operators.

data PrimArith :: *

Primitive arithmetic, logic, and comparison opretors. We expect the backend/machine to be able to implement these directly.

For the Shift Right operator, the type that it is used at determines whether it is an arithmetic (with sign-extension) or logical (no sign-extension) shift.

Constructors

PrimArithNeg

Negation

PrimArithAdd

Addition

PrimArithSub

Subtraction

PrimArithMul

Multiplication

PrimArithDiv

Division

PrimArithMod

Modulus

PrimArithRem

Remainder

PrimArithEq

Equality

PrimArithNeq

Negated Equality

PrimArithGt

Greater Than

PrimArithGe

Greater Than or Equal

PrimArithLt

Less Than

PrimArithLe

Less Than or Equal

PrimArithAnd

Boolean And

PrimArithOr

Boolean Or

PrimArithShl

Shift Left

PrimArithShr

Shift Right

PrimArithBAnd

Bit-wise And

PrimArithBOr

Bit-wise Or

PrimArithBXOr

Bit-wise eXclusive Or

Instances

Eq PrimArith

Methods

(==) :: PrimArith -> PrimArith -> Bool

(/=) :: PrimArith -> PrimArith -> Bool

Ord PrimArith

Methods

compare :: PrimArith -> PrimArith -> Ordering

(<) :: PrimArith -> PrimArith -> Bool

(<=) :: PrimArith -> PrimArith -> Bool

(>) :: PrimArith -> PrimArith -> Bool

(>=) :: PrimArith -> PrimArith -> Bool

max :: PrimArith -> PrimArith -> PrimArith

min :: PrimArith -> PrimArith -> PrimArith

Show PrimArith

Methods

showsPrec :: Int -> PrimArith -> ShowS

show :: PrimArith -> String

showList :: [PrimArith] -> ShowS

Pretty PrimArith

Associated Types

data PrettyMode PrimArith :: *

Methods

pprDefaultMode :: PrettyMode PrimArith

ppr :: PrimArith -> Doc

pprPrec :: Int -> PrimArith -> Doc

pprModePrec :: PrettyMode PrimArith -> Int -> PrimArith -> Doc

NFData PrimArith

Methods

rnf :: PrimArith -> ()

typePrimArith :: (Anon l, GTPrim l ~ PrimType) => l -> PrimArith -> GType l

Take the type of a primitive arithmetic operator.

Primitive casting operators.

data PrimCast :: *

Primitive cast between two types.

The exact set of available casts is determined by the target platform. For example, you can only promote a Nat# to a Word32# on a 32-bit system. On a 64-bit system the Nat# type is 64-bits wide, so casting it to a Word32# would be a truncation.

Constructors

PrimCastConvert

Convert a value to a new representation with the same precision.

PrimCastPromote

Promote a value to one of similar or larger width, without loss of precision.

PrimCastTruncate

Truncate a value to a new width, possibly losing precision.

Instances

Eq PrimCast

Methods

(==) :: PrimCast -> PrimCast -> Bool

(/=) :: PrimCast -> PrimCast -> Bool

Ord PrimCast

Methods

compare :: PrimCast -> PrimCast -> Ordering

(<) :: PrimCast -> PrimCast -> Bool

(<=) :: PrimCast -> PrimCast -> Bool

(>) :: PrimCast -> PrimCast -> Bool

(>=) :: PrimCast -> PrimCast -> Bool

max :: PrimCast -> PrimCast -> PrimCast

min :: PrimCast -> PrimCast -> PrimCast

Show PrimCast

Methods

showsPrec :: Int -> PrimCast -> ShowS

show :: PrimCast -> String

showList :: [PrimCast] -> ShowS

Pretty PrimCast

Associated Types

data PrettyMode PrimCast :: *

Methods

pprDefaultMode :: PrettyMode PrimCast

ppr :: PrimCast -> Doc

pprPrec :: Int -> PrimCast -> Doc

pprModePrec :: PrettyMode PrimCast -> Int -> PrimCast -> Doc

NFData PrimCast

Methods

rnf :: PrimCast -> ()

typePrimCast :: (Anon l, GTPrim l ~ PrimType) => l -> PrimCast -> GType l

Take the type of a primitive arithmetic operator.

Primitive vector operators.

data OpVector :: *

Vector operators.

Constructors

OpVectorAlloc

Allocate a new vector of a given length number of elements.

OpVectorLength

Get the length of a vector, in elements.

OpVectorRead

Read a value from a vector.

OpVectorWrite

Write a value to a vector.

Instances

Eq OpVector

Methods

(==) :: OpVector -> OpVector -> Bool

(/=) :: OpVector -> OpVector -> Bool

Ord OpVector

Methods

compare :: OpVector -> OpVector -> Ordering

(<) :: OpVector -> OpVector -> Bool

(<=) :: OpVector -> OpVector -> Bool

(>) :: OpVector -> OpVector -> Bool

(>=) :: OpVector -> OpVector -> Bool

max :: OpVector -> OpVector -> OpVector

min :: OpVector -> OpVector -> OpVector

Show OpVector

Methods

showsPrec :: Int -> OpVector -> ShowS

show :: OpVector -> String

showList :: [OpVector] -> ShowS

typeOpVector :: forall l. (Anon l, GTPrim l ~ PrimType) => l -> OpVector -> GType l

Take the type of a primitive vector operator.

Primitive function operators.

data OpFun :: *

Operators for building function values and closures. The implicit versions work on functions of type (a -> b), while the explicit versions use expliciy closure types like C# (a -> b).

Constructors

OpFunCurry Int

Partially apply a supecombinator to some arguments, producing an implicitly typed closure.

OpFunApply Int

Apply an implicitly typed closure to some more arguments.

OpFunCReify

Reify a function into an explicit functional value.

OpFunCCurry Int

Apply an explicit functional value to some arguments, producing an explicitly typed closure.

OpFunCExtend Int

Extend an explicitly typed closure with more arguments, producing a new closure.

OpFunCApply Int

Apply an explicitly typed closure to some arguments, possibly evaluating the contained function.

Instances

Eq OpFun

Methods

(==) :: OpFun -> OpFun -> Bool

(/=) :: OpFun -> OpFun -> Bool

Ord OpFun

Methods

compare :: OpFun -> OpFun -> Ordering

(<) :: OpFun -> OpFun -> Bool

(<=) :: OpFun -> OpFun -> Bool

(>) :: OpFun -> OpFun -> Bool

(>=) :: OpFun -> OpFun -> Bool

max :: OpFun -> OpFun -> OpFun

min :: OpFun -> OpFun -> OpFun

Show OpFun

Methods

showsPrec :: Int -> OpFun -> ShowS

show :: OpFun -> String

showList :: [OpFun] -> ShowS

typeOpFun :: (Anon l, GTPrim l ~ PrimType) => l -> OpFun -> GType l

Take the type of a primitive function operator.

Primitive error handling

data OpError :: *

Operators for runtime error reporting.

Constructors

OpErrorDefault

Raise an error due to inexhaustive case expressions.

Instances

Eq OpError

Methods

(==) :: OpError -> OpError -> Bool

(/=) :: OpError -> OpError -> Bool

Ord OpError

Methods

compare :: OpError -> OpError -> Ordering

(<) :: OpError -> OpError -> Bool

(<=) :: OpError -> OpError -> Bool

(>) :: OpError -> OpError -> Bool

(>=) :: OpError -> OpError -> Bool

max :: OpError -> OpError -> OpError

min :: OpError -> OpError -> OpError

Show OpError

Methods

showsPrec :: Int -> OpError -> ShowS

show :: OpError -> String

showList :: [OpError] -> ShowS

typeOpError :: ((~#) * * (GTPrim l) PrimType, Anon l) => l -> OpError -> GType l

Take the type of a primitive error function.

makeXErrorDefault :: (GXBoundCon l ~ DaConBound, GXPrim l ~ PrimVal, GTPrim l ~ PrimType) => Text -> Integer -> GExp l

Primitive literals

data PrimLit

Constructors

PrimLitBool !Bool

A boolean literal.

PrimLitNat !Integer

A natural literal, with enough precision to count every heap object.

PrimLitInt !Integer

An integer literal, with enough precision to count every heap object.

PrimLitSize !Integer

An unsigned size literal, with enough precision to count every addressable byte of memory.

PrimLitWord !Integer !Int

A word literal, with the given number of bits precison.

PrimLitFloat !Double !Int

A floating point literal, with the given number of bits precision.

PrimLitChar !Char

A character literal.

PrimLitTextLit !Text

Text literals (UTF-8 encoded)

Instances

Eq PrimLit

Methods

(==) :: PrimLit -> PrimLit -> Bool

(/=) :: PrimLit -> PrimLit -> Bool

Ord PrimLit

Methods

compare :: PrimLit -> PrimLit -> Ordering

(<) :: PrimLit -> PrimLit -> Bool

(<=) :: PrimLit -> PrimLit -> Bool

(>) :: PrimLit -> PrimLit -> Bool

(>=) :: PrimLit -> PrimLit -> Bool

max :: PrimLit -> PrimLit -> PrimLit

min :: PrimLit -> PrimLit -> PrimLit

Show PrimLit

Methods

showsPrec :: Int -> PrimLit -> ShowS

show :: PrimLit -> String

showList :: [PrimLit] -> ShowS

readPrimLit :: String -> Maybe PrimLit

Read the name of a primitive literal.

primLitOfLiteral :: Literal -> PrimLit

Convert a literal to a Tetra name.

pattern PTrue :: forall t. ((~#) * * (GTPrim t) PrimType, (~#) * * (GXBoundCon t) DaConBound) => GPat t

pattern PFalse :: forall t. ((~#) * * (GTPrim t) PrimType, (~#) * * (GXBoundCon t) DaConBound) => GPat t

Orphan instances

Pretty PrimLit

Associated Types

data PrettyMode PrimLit :: *

Methods

pprDefaultMode :: PrettyMode PrimLit

ppr :: PrimLit -> Doc

pprPrec :: Int -> PrimLit -> Doc

pprModePrec :: PrettyMode PrimLit -> Int -> PrimLit -> Doc

Pretty PrimVal

Associated Types

data PrettyMode PrimVal :: *

Methods

pprDefaultMode :: PrettyMode PrimVal

ppr :: PrimVal -> Doc

pprPrec :: Int -> PrimVal -> Doc

pprModePrec :: PrettyMode PrimVal -> Int -> PrimVal -> Doc

Pretty PrimType

Associated Types

data PrettyMode PrimType :: *

Methods

pprDefaultMode :: PrettyMode PrimType

ppr :: PrimType -> Doc

pprPrec :: Int -> PrimType -> Doc

pprModePrec :: PrettyMode PrimType -> Int -> PrimType -> Doc

NFData PrimLit

Methods

rnf :: PrimLit -> ()

NFData PrimVal

Methods

rnf :: PrimVal -> ()

NFData PrimType

Methods

rnf :: PrimType -> ()