Technique.Translate

Given a Technique Procedure (concrete syntax tree), translate it into an internalized representation (abstract syntax tree) that can be subsequently executed (that is, interpreted; evaluated).

Documentation

data Environment

Environment in the type-theory sense of the word: the map(s) between names and their bindings.

Constructors

Environment

Fields

• environmentVariables :: Map Identifier Name
• environmentFunctions :: Map Identifier Function
• environmentRole :: Attribute
• environmentSource :: Source
• environmentAccumulated :: Step

Instances

Eq Environment

Defined in Technique.Translate

Methods

(==) :: Environment -> Environment -> Bool

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

Show Environment

Defined in Technique.Translate

Methods

showsPrec :: Int -> Environment -> ShowS

show :: Environment -> String

showList :: [Environment] -> ShowS

MonadState Environment Translate

Defined in Technique.Translate

Methods

get :: Translate Environment

put :: Environment -> Translate ()

state :: (Environment -> (a, Environment)) -> Translate a

emptyEnvironment :: Environment

newtype Translate a

Constructors

Translate (StateT Environment (Except CompilationError) a)

Instances

Monad Translate

Defined in Technique.Translate

Methods

(>>=) :: Translate a -> (a -> Translate b) -> Translate b

(>>) :: Translate a -> Translate b -> Translate b

return :: a -> Translate a

Functor Translate

Defined in Technique.Translate

Methods

fmap :: (a -> b) -> Translate a -> Translate b

(<$) :: a -> Translate b -> Translate a

Applicative Translate

Defined in Technique.Translate

Methods

pure :: a -> Translate a

(<*>) :: Translate (a -> b) -> Translate a -> Translate b

liftA2 :: (a -> b -> c) -> Translate a -> Translate b -> Translate c

(*>) :: Translate a -> Translate b -> Translate b

(<*) :: Translate a -> Translate b -> Translate a

MonadState Environment Translate

Defined in Technique.Translate

Methods

get :: Translate Environment

put :: Environment -> Translate ()

state :: (Environment -> (a, Environment)) -> Translate a

MonadError CompilationError Translate

Defined in Technique.Translate

Methods

throwError :: CompilationError -> Translate a

catchError :: Translate a -> (CompilationError -> Translate a) -> Translate a

runTranslate :: Environment -> Translate a -> Either CompilationError (a, Environment)

Take a translator action and an environment and spin it up into a Step or nest of Steps (Subroutine) suitable for interpretation. In other words, translate between the concrete syntax types and the abstract syntax we can feed to an evaluator.

translateTechnique :: Technique -> Translate [Function]

translateProcedure :: Procedure -> Translate Function

translateBlock :: Block -> Translate Step

Blocks are scoping mechanisms, so accumulated environment is discarded once we finish resolving names within it.

translateStatement :: Statement -> Translate ()

translateExpression :: Expression -> Translate Step

Note that this does NOT add the steps to the Environment.

registerProcedure :: Offset -> Function -> Translate ()

A given procedure call can either be to a user declared in-scope procedure or to a primative builtin. We have Invocation as the Step constructors for these cases.

failBecause :: Offset -> FailureReason -> Translate a

lookupVariable :: Offset -> Identifier -> Translate Name

insertVariable :: Offset -> Identifier -> Translate Name

Identifiers are valid names but Names are unique, so that we can put them into the environment map. This is where we check for reuse of an already declared name (TODO) and given the local use of the identifier a scope-local (or globally?) unique name.

appendStep :: Step -> Translate ()

Accumulate a Step.

applyRestriction :: Attribute -> Block -> Translate Step

This begins a new (more refined) scope and does *not* add its declarations or variables to the current environment.

resolveFunctions :: Step -> Translate Step

The second stage of translation phase: iterate through the Steps and where a function call is made, look up to see if we actually know what it is.

lookupFunction :: Offset -> Function -> Translate Function

setLocationFrom :: Located a => a -> Translate ()

Update the environment's idea of where in the source we are, so that if we need to generate an error message we can offer one with position information.