This library contains type definitions to represent ICurry programs.
Each name in ICurry consists of the module name, the local name inside a module, and a number. For constructors, the number is the index of the constructors in the data type definition, i.e., all constructors of a data type are numbered from 0 (to support efficient switch statements for pattern matching). For functions, the number is unique inside a module so that functions can be efficiently accessed inside a module.
IQName = (String,String,Int)
An arity of ICurry functions and constructors is just an integer.
IArity = Int
An ICurry variable is represented by a index which must be unique inside a function declaration.
IVarIndex = Int
A literal occurring in expressions.
IInt :: Int -> ILiteral: an integer literal
IChar :: Char -> ILiteral: a char literal
IFloat :: Float -> ILiteral: a float literal
An ICurry module consists of a module name, the names of imported modules, and data type and function declarations.
An ICurry data type. Since type information is not relevant here, it is represented by the name of the data type together with all constructors names with their arities.
An ICurry function declaration consisting of the function's name, arity, visibility, the positions of always demandeded arguments (where 0 denotes the first argument), and a body. Note that the demanded arguments are definitely required to evaluate the function. In some situations (e.g., complex nested case statements), more arguments might be demanded.
The visibility of ICurry entities.
Public :: IVisibility: visible and usable from other modules
Private :: IVisibility: invisible and not usable from other modules
The body specifying the behavior of an ICurry function.
IExternal :: String -> IFuncBody: the function is externally defined
IFuncBody :: IBlock -> IFuncBody: the function is defined by a block
An ICurry block. Each block consists of variable declarations, assignments, and a statement.
An ICurry variable declaration declares either a local variable or a free variable. In the subsequent assignments, graph nodes will be assigned to these variables. Instead of explicitly handling free variables, one could also use local variables and assign a node representing a value generator operation for this free variable. Since different implementations might use different strategies to deal with free variables, ICurry supports both options.
NOTE: The ICurry code assumes that the ICurry variable with index 0 always points to the root of the left-hand side when an ICurry function is invoked. This invariant must be ensured by the ICurry application!
An ICurry assignment is either an assignment to a local variable or an assignment to a successor of a node.
An ICurry statement. A return statement constructs a graph that replaces the current call. An exempt or failure statement terminates the current task. A case statement on constructors is assumed to be complete, i.e., there is a branch for each constructor of the type of the case argument. Furthermore, the branches should have the order of the constructors. For case statements on literals, there is no such restriction.
IExempt :: IStatement: failure statement
IReturn :: IExpr -> IStatement: return statement
ICaseCons :: IVarIndex -> [IConsBranch] -> IStatement
ICaseLit :: IVarIndex -> [ILitBranch] -> IStatement
An ICurry case branch over algebraic constructors. Only the constructor and its arity matching this branch is given. The assignments of constructor arguments to pattern variables must be done in the ICurry block.
An ICurry case branch over literals.
An ICurry expression.
IVar :: IVarIndex -> IExpr: a variable
IVarAccess :: IVarIndex -> [Int] -> IExpr: an access to a node argument
ILit :: ILiteral -> IExpr: a literal
IFCall :: IQName -> [IExpr] -> IExpr: a function call
ICCall :: IQName -> [IExpr] -> IExpr: a constructor call
IFPCall :: IQName -> Int -> [IExpr] -> IExpr: a partial function call with number of missing args
ICPCall :: IQName -> Int -> [IExpr] -> IExpr: a partial constructor call with number of missing args
IOr :: IExpr -> IExpr -> IExpr: a non-deterministic choice