Sifflet.Language.Expr

ELit (literals) are primitive (self-evaluating) expressions, in the sense that if x is a literal, then eval x env = EvalOk x for any environment env. I've restricted function calls to the case where the function expression is just a symbol, since otherwise it will be hard to visualize. But with some thought, it may be possible to generalize this to ECall [Expr] -- (function:args)

Constructors

EUndefined
ESymbol Symbol
ELit Value
EIf Expr Expr Expr
EList [Expr]
ECall Symbol [Expr]

Instances

eSymbol :: String -> Expr

Source

eInt :: OInt -> Expr

Source

eString :: OStr -> Expr

Source

eChar :: OChar -> Expr

Source

eFloat :: OFloat -> Expr

Source

eBool :: Bool -> Expr

Source

eFalse :: Expr

Source

eTrue :: Expr

Source

eIf :: Expr -> Expr -> Expr -> Expr

Source

eList :: [Expr] -> Expr

Source

eCall :: String -> [Expr] -> Expr

Source

Example: ePlus_2_3 = eCall + [eInt 2, eInt 3]

exprSymbols :: Expr -> [Symbol]

Source

Given an expression, return the list of names of variables occurring n the expression

exprVarNames :: Expr -> [String]

Source

exprVarNames expr returns the names of variables in expr that are UNBOUND in the base environment. This may not be ideal, but it's a start.

type ExprTree = Tree ExprNode

Source

data ExprNode

Source

Constructors

ENode ExprNodeLabel EvalResult

Instances

Eq ExprNode

Show ExprNode

Repr ExprNode

data ExprNodeLabel

Source

Constructors

NUndefined
NSymbol Symbol
NLit Value

Instances

Eq ExprNodeLabel

Show ExprNodeLabel

exprNodeIoletCounter :: Env -> ExprNode -> (Int, Int)

Source

exprToTree :: Expr -> ExprTree

Source

treeToExpr :: ExprTree -> Expr

Source

Convert an expression tree (back) to an expression It will not give back the *same* expression in the case of an EList.

exprToReprTree :: Expr -> Tree String

Source

type EvalResult = EvalRes Value

Source

data EvalRes e

Source

Constructors

EvalOk e
EvalError String
EvalUntried

Instances

Monad EvalRes

Eq e => Eq (EvalRes e)

Show e => Show (EvalRes e)

evalTree :: ExprTree -> Env -> ExprTree

Source

unevalTree :: ExprTree -> ExprTree

Source

data Value

Source

Constructors

VBool OBool
VChar OChar
VInt OInt
VFloat OFloat
VStr OStr
VFun Function
VList [Value]

Instances

valueFunction :: Value -> Function

Source

data Functions

Source

A collection of functions, typically to be saved or exported or read from a file

Constructors

Functions [Function]

Instances

data Function

A function may have a name and always has an implementation

Constructors

Function (Maybe String) [VpType] VpType FunctionImpl

Instances

functionName :: Function -> String

Source

functionNArgs :: Function -> Int

Source

functionArgTypes :: Function -> [VpType]

Source

functionResultType :: Function -> VpType

Source

functionType :: Function -> ([VpType], VpType)

Source

Type type of a function, a tuple of (arg types, result type)

functionArgNames :: Function -> [String]

Source

functionBody :: Function -> Expr

Source

functionImplementation :: Function -> FunctionImpl

Source

type FunctionDefTuple = (String, [String], [VpType], VpType, Expr)

Source

functionToDef :: Function -> FunctionDefTuple

Source

functionFromDef :: FunctionDefTuple -> Function

Source

data FunctionImpl

Source

Constructors

Primitive ([Value] -> EvalResult)
Compound [String] Expr

Instances

Read FunctionImpl

Show FunctionImpl

data VpType

Source

Constructors

VpTypeBool
VpTypeChar
VpTypeNum
VpTypeString
VpTypeList VpType
VpTypeFunction [VpType] VpType
VpTypeVar String

Instances

typeMatch :: VpType -> Value -> TypeEnv -> SuccFail TypeEnv

Source

Try to match a single type and value, may result in binding a type variable in a new environment or just the old environment

typeCheck :: [String] -> [VpType] -> [Value] -> SuccFail [Value]

Source

Check whether the values agree with the types (which may be abstract)

This is *probably* too lenient in the case of type variables: it can pass a mixed-type list.

vpTypeOf :: Value -> SuccFail VpType

Source

Determine the type of a value. May result in a type variable.

type TypeEnv = Map String VpType

Source

emptyTypeEnv :: TypeEnv

Source

type Env = [EnvFrame]

Source

emptyEnv :: Env

Source

makeEnv :: [String] -> [Value] -> Env

Source

extendEnv :: [String] -> [Value] -> Env -> Env

Source

envInsertL :: Env -> [String] -> [Value] -> Env

Source

Insert names and values from lists into an environment

envPop :: Env -> Env

Source

Return to the environment prior to an extendEnv

envIns :: Env -> String -> Value -> Env

Source

envSet :: Env -> String -> Value -> Env

Source

envGet :: Env -> String -> Value

Source

Get the value of a variable from an environment

envGetFunction :: Env -> String -> Function

Source

envLookup :: Env -> String -> Maybe Value

Source

envLookupFunction :: Env -> String -> Maybe Function

Source

envSymbols :: Env -> [String]

Source

List of all symbols bound in the environment

envFunctionSymbols :: Env -> [String]

Source

List of all symbols bound to functions in the environment

envFunctions :: Env -> Functions

Source

All the functions in the environment

eval :: Expr -> Env -> EvalResult

Source

apply :: Value -> [Value] -> Env -> Int -> EvalResult

Source

Apply a function fvalue to a list of actual arguments args in an environment env and with a limited stack size stacksize

decideTypes :: Expr -> [String] -> Env -> Either String ([VpType], VpType)

Source

decideTypes tries to find the argument types and return type of an expression considered as the body of a function, at the same time checking for consistency of inputs and outputs between the parts of the expression. It returns Right (argtypes, returntype) if successful; Left errormessage otherwise.

newUndefinedFunction :: String -> [String] -> Function

Source

undefinedTypes :: [String] -> ([VpType], VpType)

Source

ePlus :: Expr -> Expr -> Expr

Source

eTimes :: Expr -> Expr -> Expr

Source

eMinus :: Expr -> Expr -> Expr

Source

eDiv :: Expr -> Expr -> Expr

Source