As part of the refactor create an ExprData type that carries around an Expr with other implicit data. This can use a Reader monad to store the required data which will be things like line/column numbers for use in errors.

Related to #16.

let* will allow later bindings in the (name, expression) list to refer to earlier bindings when being defined.

Implement a way to convert an expression to a more convenient, human-readable form.

Some examples for string representations:

Fun -> "fn"
Number 1 -> "1"

After hitting a wall with IO the language probably needs to be re-written in something else that isn't as pure as Haskell but supports the same pattern-matching and recursive logic programming as Haskell so that the logic can be ported easily.

The lexer, parser and evaluator should all use Monad transformers to pass around state and other associated information to get more useful error messages.

In addition we can then use a Monad transformer during evaluation to get access to the IO Monad and execute the program with IO.

The sort of structure we want is to be able to store information like line/column numbers of each token at the lexer stage. Then in the parser stage use these line/column numbers if any errors come up (also passing around the string that represents the program so that it can be highlighted when printing error messages).

The parser will also associate these line/column numbers with each expression that it parses.

Finally, when it comes to the evaluation stage each expression will have access to some information about where it is in the original file (line/column number) and if any errors occur more information can be displayed (if a function received too many arguments we can display the name of the function and whereabouts it was called).

Add a Char fundamental type to the language. To avoid clashes with Haskell's Char type it should probably be called "Chr" internally.

This should work in a similar way to the 'def' macro, however this also allows a function to be recursive.

It should bind a name to a function whose name is also the binding name in the 'defn'.

Without this there is no way to define recursive functions, as they cannot refer to themselves in a let expression.

A tool that takes a file containing slang source code and interprets this, producing the result of evaluating the file to stdout.

Call it something like 'slerp' (slang + interp(ret))

Associate a line number with tokens when they are being parsed in the Lexer.

Also associate a first/last line number with expressions when they are parsed in the Parser.

This means adding syntax for it and supporting it at some stage of the interpretation (using some kind of metadata on the Fun Expr)?

At the moment a let can only be used to define one binding, we should allow it to define more than one at once.

Note: this will not have the semantics of allowing later bindings to access earlier ones, this should be implemented as a let* in a macro.

Make Addition, Subtraction, Multiplication and Division functions at the top-level of a program so they can be used in the same way as any other functions (first-class values).

This relies on issue #2

At the moment any functions that need more than one argument are curried, leading to lots of unnecessary calling parentheses.

To get around this either:

1. Syntactical sugar for calling curried functions (e.g. only have to have one set of parens and can pass a list of arguments to the function)
2. Have functions not curried by default (this is the same as other Lisp-likes (e.g. Racket) and instead take a list of parameters.

Create a Read Eval Print Loop tool that prompts the user for stdin containing a slang expression and evaluates it, printing the result of the expression to stdout.

By adding IO to the language it can support actual use cases.

Add a fundamental function called "writeBytes" that takes a writeable handle as its first argument and a list of bytes to write to that handle.

Add a fundamental function called "write" that takes a writeable handle as its first argument and a string to write to that handle.

Add a fundamental function called "readByte" that takes a handle as its first argument and attempts to read a single byte from that handle.

Add a fundamental function called "readChar" that takes a handle as its first argument and attempts to read a single UTF-8 encoded char from that handle.

Add a fundamental function called "readLine" that takes a handle as its first argument and attempts to buffer read a UTF-8 encoded string from that handle delimited by an end of line character ("\n\r").

The 'macro' should expand to a let expression that encompasses the whole program up to that point with the binding being made.

e.g.

(def foo 10)
(def bar 10)

(+ foo bar)

expands to

(let foo 10
  (let bar 10
    (+ foo bar)))