Grin.Grin

Documentation

data Callable

Constructors

Continuation

Function

Closure

LocalFunction

Primitive'

Instances

Eq Callable

Ord Callable

Show Callable

data Exp

Constructors

Exp :>>= Lam

Sequencing - the same as >>= for monads.

BaseOp

Fields

expBaseOp :: BaseOp

expArgs :: [Val]

App

Application of functions and builtins

Fields

expFunction :: Atom

expArgs :: [Val]

expType :: [Ty]

Prim

Primitive operation

Fields

expPrimitive :: Prim

expArgs :: [Val]

expType :: [Ty]

Case

Case statement

Fields

expValue :: Val

expAlts :: [Lam]

Return

Return a value

Fields

expValues :: [Val]

add some new variables to the GC roots for a subcomputation

Error

Abort with an error message, non recoverably.

Fields

expError :: String

expType :: [Ty]

Call

Call or jump to a callable

Fields

expValue :: Val

expArgs :: [Val]

expType :: [Ty]

expJump :: Bool

Jump is equivalent to a call except it deallocates the region it resides in before transfering control

expFuncProps :: FuncProps

expInfo :: Info

NewRegion

create a new region and pass it to its argument

Fields

expLam :: Lam

the computation that is passed the newly created computation

expInfo :: Info

Alloc

allocate space for a number of values in the given region

Fields

expValue :: Val

expCount :: Val

expRegion :: Val

expInfo :: Info

Let

A let of local functions

Fields

expDefs :: [FuncDef]

expBody :: Exp

expFuncCalls :: (Set Atom, Set Atom)

cache

expIsNormal :: Bool

cache, True = definitely normal, False = maybe normal

expNonNormal :: Set Atom

cache, a superset of functions called in non-tail call position.

expInfo :: Info

MkClosure

create a closure

Fields

expValue :: Val

expArgs :: [Val]

expRegion :: Val

expType :: [Ty]

expInfo :: Info

MkCont

Make a continuation, always allocated on region encompasing expLam

Fields

expCont :: Lam

the continuation routine

expLam :: Lam

the computation that is passed the newly created computation

expInfo :: Info

GcRoots

Fields

expValues :: [Val]

add some new variables to the GC roots for a subcomputation

expBody :: Exp

Instances

Eq Exp

Ord Exp

Show Exp

CanType Exp

Tickleable Val Exp

Tickleable Exp Exp

Tickleable Exp Lam

PPrint Doc Exp

FreeVars Exp [Var]

FreeVars Exp [Tag]

FreeVars Exp (Set (Var, Ty))

FreeVars Exp (Set Var)

FreeVars Exp (Set Tag)

FreeVars Exp (GSet Var)

FreeVars Exp (GSet Tag)

FreeVars Exp (Set Var, Set Tag)

FreeVars Exp (GSet Var, GSet Tag)

data FuncDef

Constructors

FuncDef

Fields

funcDefName :: Atom

funcDefBody :: Lam

funcDefCall :: Val

funcDefProps :: FuncProps

Instances

Eq FuncDef

Ord FuncDef

Show FuncDef

Tickleable Lam FuncDef

FreeVars FuncProps a => FreeVars FuncDef a

Tickleable (Atom, Lam) FuncDef

data FuncProps

Constructors

FuncProps

Fields

funcInfo :: Info

funcFreeVars :: Set Var

funcTags :: Set Tag

funcType :: ([Ty], [Ty])

funcExits :: Perhaps

function quits the program

funcCuts :: Perhaps

function cuts to a value

funcAllocs :: Perhaps

function allocates memory

funcCreates :: Perhaps

function allocates memory and stores or returns it

funcLoops :: Perhaps

function may loop

Instances

Eq FuncProps

Ord FuncProps

Show FuncProps

FreeVars FuncProps (Set Var)

FreeVars FuncProps (Set Tag)

FreeVars FuncProps (GSet Var)

FreeVars FuncProps (GSet Tag)

data Grin

Constructors

Grin

Fields

grinEntryPoints :: GMap Atom FfiExport

grinPhase :: !Phase

grinTypeEnv :: TyEnv

grinFunctions :: [FuncDef]

grinSuspFunctions :: Set Atom

grinPartFunctions :: Set Atom

grinStats :: !Stat

grinCafs :: [(Var, Val)]

Instances

Tickleable Lam Grin

data TyThunk

Constructors

TyNotThunk

not the thunk

TyPApp (Maybe Ty) Atom

can be applied to (possibly) an argument, and what results

TySusp Atom

can be evaluated and calls what function

Instances

Eq TyThunk

Show TyThunk

data Lam

Constructors

[Val] :-> Exp

Instances

Eq Lam

Ord Lam

Show Lam

Tickleable Exp Lam

Tickleable Lam Grin

Tickleable Lam FuncDef

FreeVars Lam [Var]

FreeVars Lam (Set (Var, Ty))

FreeVars Lam (Set Var)

FreeVars Lam (Set Tag)

FreeVars Lam (GSet Var)

FreeVars Lam (GSet Tag)

Tickleable (Atom, Lam) FuncDef

data Phase

Constructors

PhaseInit

PostInlineEval

PostAeOptimize

PostDevolve

Instances

Enum Phase

Eq Phase

Ord Phase

Show Phase

data BaseOp

Constructors

Demote

Promote

Eval

Apply [Ty]

StoreNode !Bool

Redirect

Overwrite

PeekVal

PokeVal

Consume

GcTouch

Coerce Ty

GcPush

NewRegister

ReadRegister

WriteRegister

Instances

Eq BaseOp

Ord BaseOp

Show BaseOp

type Tag = Atom

updateFuncDefProps :: FuncDef -> FuncDef

data Ty

Constructors

TyPtr Ty

pointer to a memory location which contains its argument

TyNode

a whole node

TyINode

a whole possibly indirect node

TyAttr Ty Ty

attach an attribute to a type

TyAnd Ty Ty

boolean conjunction of types

TyOr Ty Ty

boolean disjunction of types

TyPrim Ty

a basic type

TyUnit

type of Unit

TyCall Callable [Ty] [Ty]

something call,jump, or cut-to-able

TyRegion

a region

TyGcContext

the context for garbage collection

TyRegister Ty

a register contains a mutable value, the register itself cannot be addressed, hence they may not be returned from functions or passed as arguments.

TyComplex Ty

A complex version of a basic type

TyVector !Int Ty

A vector of a basic type

TyUnknown

an unknown possibly undefined type, All of these must be eliminated by code generation

Instances

Eq Ty

Ord Ty

Show Ty

TypeNames Ty

ToCmmTy Ty

FreeVars Val (Set (Var, Ty))

FreeVars Exp (Set (Var, Ty))

FreeVars Lam (Set (Var, Ty))

newtype TyEnv

Constructors

TyEnv (GMap Atom TyTy)

Instances

Monoid TyEnv

data TyTy

Constructors

TyTy

Fields

tySlots :: [Ty]

tyReturn :: [Ty]

tyThunk :: TyThunk

tySiblings :: Maybe [Atom]

tyTy :: TyTy

data Val

Constructors

NodeC !Tag [Val]

Complete node, of type TyNode

Const Val

constant data, only Lit, Const and NodeC may be children. of type TyINode

Lit !Number Ty

Literal

Var !Var Ty

Variable

Unit

Empty value used as placeholder

ValPrim Prim [Val] Ty

Primitive value

Index Val Val

A pointer incremented some number of values (Index v 0) == v

Item Atom Ty

Specific named thing. function, global, region, etc..

ValUnknown Ty

Unknown or unimportant value

Instances

Eq Val

Ord Val

Show Val

ConNames Val

CanType Val

FromVal Val

ToVal Val

Tickleable Val Val

Tickleable Val Exp

DocLike d => PPrint d Val

FreeVars Val [Var]

FreeVars Val [Tag]

FreeVars Val (Set (Var, Ty))

FreeVars Val (Set Var)

FreeVars Val (Set Tag)

FreeVars Val (GSet Var)

FreeVars Val (GSet Tag)

ToVal (Val, Val)

newtype Var

Constructors

V Int

Instances

Enum Var

Eq Var

Ord Var

Show Var

Intjection Var

DocLike d => PPrint d Var

FreeVars FuncProps (Set Var)

FreeVars FuncProps (GSet Var)

FreeVars Val [Var]

FreeVars Val (Set (Var, Ty))

FreeVars Val (Set Var)

FreeVars Val (GSet Var)

FreeVars Exp [Var]

FreeVars Exp (Set (Var, Ty))

FreeVars Exp (Set Var)

FreeVars Exp (GSet Var)

FreeVars Lam [Var]

FreeVars Lam (Set (Var, Ty))

FreeVars Lam (Set Var)

FreeVars Lam (GSet Var)

FreeVars Exp (Set Var, Set Tag)

FreeVars Exp (GSet Var, GSet Tag)

Eq (GSet Var)

Ord (GSet Var)

Monoid (GSet Var)

HasSize (GSet Var)

IsEmpty (GSet Var)

SetLike (GSet Var)

Collection (GSet Var)

Unionize (GSet Var)

Eq v => Eq (GMap Var v)

Ord v => Ord (GMap Var v)

Monoid (GMap Var v)

HasSize (GMap Var v)

IsEmpty (GMap Var v)

MapLike (GMap Var v)

SetLike (GMap Var v)

Collection (GMap Var v)

Unionize (GMap Var v)

extendTyEnv :: [FuncDef] -> TyEnv -> TyEnv

createFuncDef :: Bool -> Atom -> Lam -> FuncDef

setGrinFunctions :: [(Atom, Lam)] -> Grin -> Grin

grinFuncs :: Grin -> [(Atom, Lam)]

emptyGrin :: Grin

tyINode :: Ty

lazy node sptr_t

tyDNode :: Ty

strict node wptr_t

findArgs :: Monad m => TyEnv -> Atom -> m [Ty]

findArgsType :: Monad m => TyEnv -> Atom -> m ([Ty], [Ty])

findTyTy :: Monad m => TyEnv -> Atom -> m TyTy

gEval :: Val -> Exp

grinEntryPointNames :: Grin -> [Atom]

isHole :: Val -> Bool

isValUnknown :: Val -> Bool

isVar :: Val -> Bool

n0 :: Val

n1 :: Val

n2 :: Val

n3 :: Val

p0 :: Val

p1 :: Val

p2 :: Val

p3 :: Val

partialTag :: Tag -> Int -> Tag

phaseEvalInlined :: Phase -> Bool

properHole :: Ty -> Val

tagFlipFunction :: Atom -> Atom

tagHole :: Atom

tagInfo :: Atom -> TagInfo

data TagInfo

Constructors

TagPApp !Int !Atom

TagSusp !Bool !Atom

TagDataCons

TagTypeCons

TagTypePApp !Int Tag

TagFunc

tagIsFunction :: Atom -> Bool

tagIsPartialAp :: Atom -> Bool

tagIsSuspFunction :: Atom -> Bool

tagIsTag :: Atom -> Bool

tagIsWHNF :: Atom -> Bool

tagToFunction :: Monad m => Atom -> m Atom

tagUnfunction :: Monad m => Tag -> m (Int, Tag)

v0 :: Var

v1 :: Var

v2 :: Var

v3 :: Var

lamExp :: Lam -> Exp

lamBind :: Lam -> [Val]

valIsNF :: Val -> Bool