-\section{Extensions}\label{sec:ext}
-\subsection{Higher order functions}
-The nature of the type checking algorithm already included type checking and
-inferring the type of higher order functions. Since we allow constants there is
-a difference between \SI{read} and \SI{read()}. To make this difference we
-introduced a separate type of expression called a \SI{FuncType}, this type
-encodes a function with arity $0$.
-
-As all other data types a function type object occupies one item on the stack
-which contains a heap pointer. The heap pointer points to a position on the
-heap that stores, in increasing addresses, the function identification number,
-the number of arguments already given and finally the argument values.
-For example the following snippet shows the representation of the incomplete
-function \SI{plus} that already has two arguments.
-\begin{SPLCode}
-//SPLCode
-plus(x, y, z){ return x + y + z; }
-
-main(){
- var a = plus(4, 3);
-}
-
-/*# | Stack
-001 | 001 //Pointer to the
-... |
-
- # | Heap
-001 | 008 //Function identification number
-002 | 002 //Available arguments
-003 | 004 //Argument 1
-004 | 003 //Argument 2
-*/
-\end{SPLCode}
-
-When an incomplete function is declared we save the remaining arity in our
-state to be able to know when a function is complete and can be executed. When
-a function is still not complete the function is copied in totality and the
-available arguments position on the heap is increased accordingly and the
-arguments are added on the heap.
-
-Function numbers are integers that identify the function. Normally we address
-functions using labels but it is not possible to store labels on the heap or on
-the stack. Therefore we include a function in the preamble that is basically a
-dictionary from integers to labels. All functions have their unique number that
-identifies them via the function dictionary called \SI{1func}. When we want to
-call a function that is identified by an address instead of a label we first
-collect all the arguments from the heap and add the arguments given in the
-function call. Calculating the number of arguments that have to be popped from
-the heap is done at runtime using the \emph{Available Arguments} value stored
-on the heap. Instead of jumping to a label we jump to the \SI{1func} function
-and make sure the identification is situated in register R5. \SI{1func} then
-makes sure the correct function is branched to and the caller can resume the
-normal execution path.
-
-
-\subsection{Syntactic sugars}\label{ssec:synsugar}
-Several small syntactic sugars have been added on several levels of processing
-to make writing programs more easy.
-
-\subsubsection{Literal strings}
-While there are no literal strings one can print lists of characters. Entering
-lists of characters can be cumbersome and therefore a shorthand notation is
-added to define literal strings using double quotes. During the lexing phase
-the string is lexed as a single token and during parsing the token is
-transformed to a equal character list representation. The following example
-shows the syntax before transformation and the syntax after. Note that just as
-in characters, literal strings can contain escape characters.
-
-\begin{SPLCode}
-//Before transformation
-var a = "Hello world!";
-//After transformation
-var a = 'H':'e':'l':'l':'o':' ':'w':'o':'r':'l':'d':'!':[]
-\end{SPLCode}
-
-\subsubsection{Anonymous functions}
-When the programmers wants to use small functions that consist of one line to
-for example use the operators in a functional way the programmer has to make a
-named function for every operator. In some cases it is easy to do this inline
-using anonymous functions. A small syntactic sugar has been added that will
-inline anonymous functions to non-anonymous functions during the parsing phase.
-The following snippet is an example of a filter on even values before and after
-transformation.
-
-\begin{SPLCode}
-//Before transformation
-main(){
- var a = filter(\x->x % 2 == 0, 1 : 2 : 3 : 4 : 5 : []);
-}
-
-//After transformation
-1lambda_23(x){
- return x % 2 == 0;
-}
-
-main(){
- var a = filter(1lambda_23, 1 : 2 : 3 : 4 : 5 : []);
-}
-\end{SPLCode}
-
-Every anonymous functions gets a unique name outside the namespace of legal
-names for functions making sure the name is unique. By implementing the
-transformation in the parsing phase the function is automatically checked
-or inferred on type.
-
-\subsubsection{Variable arguments printing}
-To ease the programmer we have included a parse-level transformation that
-transforms \SI{print} with multiple arguments to multiple \SI{print} function
-calls with a single argument. The following example shows the syntax before the
-transformation and the syntax after the transformation.
-
-\begin{SPLCode}
-//Before transformation
-print("abc", 42, 'c', "da\n");
-
-//After transformation
-print('a':'b':'c':[]);
-print(42);
-print('c');
-print('d':'a':'\n':[]);
-\end{SPLCode}