Language.Sifflet.Expr

Documentation

data ArgSpec

Constructors

ArgSpec

Fields

argName :: String

argInlets :: Int

Instances

Eq ArgSpec

Show ArgSpec

aspecsLookup :: String -> [ArgSpec] -> Maybe Int

Try to find the number of inlets for an argument from a list of ArgSpec

type EvalResult = EvalRes Value

data EvalRes e

Constructors

EvalOk e

EvalError String

EvalUntried

Instances

Monad EvalRes

Functor EvalRes

Applicative EvalRes

Eq e => Eq (EvalRes e)

Show e => Show (EvalRes e)

exprToValue :: Expr -> SuccFail Value

The value of an expression in the base environment.

valueToLiteral :: Value -> SuccFail Expr

valueToLiteral' :: Value -> Expr

newtype Symbol

Constructors

Symbol String

Instances

Eq Symbol

Read Symbol

Show Symbol

Pretty Symbol

Repr Symbol

HsPretty Symbol

PyPretty Symbol

ToXml Symbol

Symbols

type OStr = String

type OBool = Bool

type OChar = Char

data Expr

A more highly "parsed" type of expression

Function calls have two kinds: 1. ECall: restricted to the case where the function expression is just a symbol, since otherwise it will be hard to visualize. 2. EApp: allows any expression to be the function, but is applied to only one argument. For now, the type checker will convert ECall expressions to EApp expressions. Ultimately, the two variants ought to be unified.

The constructors EOp and EGroup are not used in Sifflet itself, but they are needed for export to Python, Haskell, and similar languages; they allow a distinction between operators and functions, and wrapping expressions in parentheses. EGroup e represents parentheses used for grouping: (e); it is not used for other cases of parentheses, e.g., around the argument list in a function call.]

Constructors

EUndefined

ESymbol Symbol

EBool Bool

EChar Char

ENumber Number

EString String

EIf Expr Expr Expr

if test branch1 branch2

EList [Expr]

ELambda Symbol Expr

EApp Expr Expr

apply function to argument

ECall Symbol [Expr]

function name, arglist

EOp Operator Expr Expr

binary operator application

EGroup Expr

grouping parentheses

Instances

Eq Expr

Show Expr

Repr Expr

HsPretty Expr

HsPretty expressions. This is going to be like in Python.hs.

PyPretty Expr

Expr as an instance of PyPretty. This instance is only for Exprs as Python exprs, for export to Python! It will conflict with the one in ToHaskell.hs (or Haskell.hs).

The EOp case needs work to deal with precedences and avoid unnecessary parens. Note that this instance declaration is for *Python* Exprs. Haskell Exprs of course should not be pretty-printed the same way!

ToXml Expr

Expr

eSymbol :: String -> Expr

eSym :: String -> Expr

eInt :: Integer -> Expr

eString :: OStr -> Expr

eChar :: OChar -> Expr

eFloat :: Double -> Expr

toLambdaExpr :: [String] -> Expr -> SuccFail Expr

Try to convert the arguments and body of a function to a lambda expression. Fails if there are no arguments, since a lambda expression requires one. If there are multiple arguments, then we get a nested lambda expression.

callToApp :: Expr -> Expr

Convert an ECall expression to an EApp expression

mapply :: Expr -> [Expr] -> Expr

Helper for callToApp, but may have other uses. Creates an EApp expression representing a function call with possibly many arguments.

appToCall :: Expr -> Expr

Convert an EApp expression to an ECall expression

mcall :: Expr -> [Expr] -> Expr

Helper for appToCall, but may have other uses. Creates an ECall expression.

exprIsAtomic :: Expr -> Bool

Is an expression atomic? Atomic expressions do not need parentheses in any reasonable language, because there is nothing to be grouped (symbols, literals) or in the case of lists, they already have brackets which separate them from their neighbors.

All lists are atomic, even if they are not literals, because (for example) we can remove parentheses from ([a + b, 7])

exprIsCompound :: Expr -> Bool

Compound = non-atomic

eBool :: Bool -> Expr

eFalse :: Expr

eTrue :: Expr

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

eList :: [Expr] -> Expr

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

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

exprIsLiteral :: Expr -> Bool

Is an Expr a literal? A literal is a boolean, character, number, string, or list of literals. We (should) only allow user input expressions to be literal expressions.

exprSymbols :: Expr -> [Symbol]

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

exprVarNames :: Expr -> [String]

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.

data Operator

An operator, such as * or + An operator is associative, like +, if (a + b) + c == a + (b + c). Its grouping is left to right if (a op b op c) means (a op b) op c; right to left if (a op b op c) means a op (b op c). Most operators group left to right.

Constructors

Operator

Fields

opName :: String

opPrec :: Precedence

opAssoc :: Bool

associative?

opGrouping :: OperatorGrouping

Instances

Eq Operator

Show Operator

Pretty Operator

HsPretty Operator

PyPretty Operator

type Precedence = Int

Operator priority, normally is > 0 or >= 0, but does that really matter? I think not.

data OperatorGrouping

Operator grouping: left to right or right to left, or perhaps not at all

Constructors

GroupLtoR

GroupRtoL

GroupNone

Instances

Eq OperatorGrouping

Show OperatorGrouping

data Value

Constructors

VBool OBool

VChar OChar

VNumber Number

VString OStr

VFun Function

VList [Value]

Instances

Eq Value

Show Value

Repr Value

ToXml Value

Values Still used in exprToXml in the EList case :-(

valueFunction :: Value -> Function

newtype Functions

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

Constructors

Functions [Function]

Instances

Eq Functions

Show Functions

ToXml Functions

data Function

A function may have a name and always has an implementation

Constructors

Function (Maybe String) [Type] Type FunctionImpl

Instances

Eq Function

We need to be able to say functions are equal (or not) in order to tell if environments are equal or not, in order to know whether there are unsaved changes. This is tricky since the primitive function implementations do not instantiate Eq, so if it's primitive == primitive? we go by the names alone (there's nothing else to go by). Otherwise all the parts must be equal.

Show Function

Repr Function

ToXml Function

Functions

functionName :: Function -> String

functionNArgs :: Function -> Int

functionArgSpecs :: Function -> [ArgSpec]

functionArgTypes :: Function -> [Type]

functionResultType :: Function -> Type

functionArgResultTypes :: Function -> ([Type], Type)

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

functionType :: Function -> Type

The type of a function, where (a -> b) is represented as TypeCons Function [a, b]

functionArgNames :: Function -> [String]

functionBody :: Function -> Expr

functionImplementation :: Function -> FunctionImpl

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

functionToDef :: Function -> FunctionDefTuple

functionFromDef :: FunctionDefTuple -> Function

data FunctionImpl

Constructors

Primitive ([Value] -> EvalResult)

Compound [String] Expr

Instances

Read FunctionImpl

Show FunctionImpl

type TypeVarName = String

Type variable name

type TypeConsName = String

Type constructor name

data Type

A Type is either a type variable or a constructed type with a constructor and a list of type parameters

Constructors

TypeVar TypeVarName

TypeCons TypeConsName [Type]

Instances

Eq Type

Show Type

ToXml Type

Types

typeBool :: Type

typeChar :: Type

typeNum :: Type

typeString :: Type

typeList :: Type -> Type

typeFunction :: [Type] -> Type -> Type

The type of a function, from its argument types and result type, where (a -> b) is represented as TypeCons Function [a, b]. Note that for n-ary functions, n > 2 implies nested function types: (a -> b -> c) is represented as TypeCons Function [a, TypeCons Function [b, c]], etc.

type Env = [EnvFrame]

emptyEnv :: Env

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

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

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

Insert names and values from lists into an environment

envPop :: Env -> Env

Return to the environment prior to an extendEnv

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

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

envGet :: Env -> String -> Value

Get the value of a variable from an environment

envGetFunction :: Env -> String -> Function

envLookup :: Env -> String -> Maybe Value

envLookupFunction :: Env -> String -> Maybe Function

envSymbols :: Env -> [String]

List of all symbols bound in the environment

envFunctionSymbols :: Env -> [String]

List of all symbols bound to functions in the environment

envFunctions :: Env -> Functions

All the functions in the environment

eval :: Expr -> Env -> EvalResult

evalWithLimit :: Expr -> Env -> Int -> EvalResult

stackSize :: Int

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

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

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

ePlus :: Expr -> Expr -> Expr

eTimes :: Expr -> Expr -> Expr

eMinus :: Expr -> Expr -> Expr

eDiv :: Expr -> Expr -> Expr

eMod :: Expr -> Expr -> Expr

eAdd1 :: Expr -> Expr

eSub1 :: Expr -> Expr

eEq :: Expr -> Expr -> Expr

eNe :: Expr -> Expr -> Expr

eGt :: Expr -> Expr -> Expr

eGe :: Expr -> Expr -> Expr

eLt :: Expr -> Expr -> Expr

eLe :: Expr -> Expr -> Expr

eZerop :: Expr -> Expr

ePositivep :: Expr -> Expr

eNegativep :: Expr -> Expr

baseEnv :: Env