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 PureHeap Supply

Instances

Show Heap

Methods

showsPrec :: Int -> Heap -> ShowS

show :: Heap -> String

showList :: [Heap] -> ShowS

type PureHeap = Map TmOccName Term

type GlobalHeap = (IntMap Term, Int)

Global heap

type Stack = [StackFrame]

The stack

data StackFrame

Constructors

Update Id

Apply Id

Instantiate Type

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

Scrutinise Type [Alt]

Instances

Show StackFrame

Methods

showsPrec :: Int -> StackFrame -> ShowS

show :: StackFrame -> String

showList :: [StackFrame] -> ShowS

Pretty StackFrame

Methods

ppr :: LFresh m => StackFrame -> m Doc

pprPrec :: LFresh m => Rational -> StackFrame -> m Doc

data Value

Constructors

Lambda (Bind Id Term)

Functions

TyLambda (Bind TyVar Term)

Type abstractions

DC DataCon [Either Term Type]

Data constructors

Lit Literal

Literals

PrimVal Text Type [Type] [Value]

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

Instances

Show Value

Methods

showsPrec :: Int -> Value -> ShowS

show :: Value -> String

showList :: [Value] -> ShowS

type State = (Heap, Stack, Term)

State of the evaluator

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

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

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

Evaluate to WHNF starting with an empty Heap and Stack

whnf :: PrimEvaluator -> BindingMap -> 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 -> BindingMap -> 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 :: BindingMap -> Heap -> Stack -> Id -> Maybe State

Force the evaluation of a variable.

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

Unwind the stack by 1

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

Update the Heap 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

primop

Arguments

:: PrimEvaluator

-> BindingMap

-> TyConMap

-> Heap

-> Stack

-> Text

Name of the primitive

-> Type

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

matchLit :: DataCon -> Literal -> Bool

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

allocate :: Heap -> Stack -> Bind (Rec [LetBinding]) Term -> State

Allocate let-bindings on the heap

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

Create a unique name and substitution for a let-binder

uniqueInHeap :: PureHeap -> Supply -> TmOccName -> (Supply, TmName)

Create a name that's unique in the heap