Clash.Core.Evaluator

Call-by-need evaluator based on the evaluator described in:

Maximilian Bolingbroke, Simon Peyton Jones, "Supercompilation by evaluation", Haskell '10, Baltimore, Maryland, USA.

Documentation

data Heap

The heap

Constructors

Heap GlobalHeap GPureHeap PureHeap Supply InScopeSet

type PureHeap = VarEnv Term

newtype GPureHeap

Constructors

GPureHeap

Fields

• unGPureHeap :: PureHeap

type GlobalHeap = (IntMap Term, Int)

Global heap

type Stack = [StackFrame]

The stack

data StackFrame

Constructors

Update Id

GUpdate Id

Apply Id

Instantiate Type

PrimApply Text PrimInfo [Type] [Value] [Term]

Scrutinise Type [Alt]

Tickish TickInfo

Instances

Show StackFrame

Defined in Clash.Core.Evaluator

Methods

showsPrec :: Int -> StackFrame -> ShowS

show :: StackFrame -> String

showList :: [StackFrame] -> ShowS

ClashPretty StackFrame

Defined in Clash.Core.Evaluator

Methods

clashPretty :: StackFrame -> Doc ()

mkTickish :: Stack -> [TickInfo] -> Stack

data Value

Constructors

Lambda Id Term

Functions

TyLambda TyVar Term

Type abstractions

DC DataCon [Either Term Type]

Data constructors

Lit Literal

Literals

PrimVal Text PrimInfo [Type] [Value]

Clash's number types are represented by their "fromInteger#" primitive function. So some primitives are values.

Suspend Term

Used by lazy primitives

Instances

Show Value

Defined in Clash.Core.Evaluator

Methods

showsPrec :: Int -> Value -> ShowS

show :: Value -> String

showList :: [Value] -> ShowS

type State = (Heap, Stack, Term)

State of the evaluator

type PrimEvaluator = Bool -> TyConMap -> Heap -> Stack -> Text -> PrimInfo -> [Type] -> [Value] -> Maybe State

Function that can evaluator primitives, i.e., perform delta-reduction

whnf' :: PrimEvaluator -> BindingMap -> TyConMap -> GlobalHeap -> Supply -> InScopeSet -> Bool -> Term -> (GlobalHeap, PureHeap, Term)

Evaluate to WHNF starting with an empty Heap and Stack

whnf :: PrimEvaluator -> TyConMap -> Bool -> State -> State

Evaluate to WHNF given an existing Heap and Stack

isScrut :: Stack -> Bool

Are we in a context where special primitives must be forced.

See [Note: forcing special primitives]

unwindStack :: State -> Maybe State

Completely unwind the stack to get back the complete term

step :: PrimEvaluator -> TyConMap -> State -> Maybe State

Small-step operational semantics.

newLetBinding :: TyConMap -> Heap -> Term -> (Heap, Id)

newLetBindings' :: TyConMap -> Heap -> [Either Term Type] -> (Heap, [Either Term Type])

mkAbstr :: (Heap, Term) -> [Either TyVar Type] -> (Heap, Term)

force :: Heap -> Stack -> Id -> Maybe State

Force the evaluation of a variable.

unwind :: PrimEvaluator -> TyConMap -> Heap -> Stack -> Value -> Maybe State

Unwind the stack by 1

update :: Heap -> Stack -> Id -> Value -> State

Update the Heap with the evaluated term

gupdate :: Heap -> Stack -> Id -> Value -> State

Update the Globals with the evaluated term

valToTerm :: Value -> Term

toVar :: Id -> Term

toType :: TyVar -> Type

apply :: Heap -> Stack -> Value -> Id -> State

Apply a value to a function

instantiate :: Heap -> Stack -> Value -> Type -> State

Instantiate a type-abstraction

naturalLiteral :: Value -> Maybe Integer

integerLiteral :: Value -> Maybe Integer

primop

Arguments

:: PrimEvaluator

-> TyConMap

-> Heap

-> Stack

-> Text

Name of the primitive

-> PrimInfo

Type of the primitive

-> [Type]

Applied types

-> [Value]

Applied values

-> Value

The current value

-> [Term]

The remaining terms which must be evaluated to a value

-> Maybe State

Evaluation of primitive operations

scrutinise :: Heap -> Stack -> Value -> [Alt] -> State

Evaluate a case-expression

substAlt :: DataCon -> [TyVar] -> [Id] -> [Either Term Type] -> Term -> Term

allocate :: Heap -> Stack -> [LetBinding] -> Term -> State

Allocate let-bindings on the heap

letSubst :: PureHeap -> Supply -> Id -> (Supply, (Id, (Id, Term)))

Create a unique name and substitution for a let-binder

uniqueInHeap :: PureHeap -> Supply -> Id -> (Supply, Id)

Create a name that's unique in the heap

wrapUnsigned :: Integer -> Integer -> Integer

wrapSigned :: Integer -> Integer -> Integer