4.1   Steps

To install LIPL interpreter, you need to follow the following steps:

1. Compile the project (using Cabal or GHC).

2. Add the directory containing the compiled binary to PATH environment variable (or, move the binary to a directory included in PATH environment variable).

3. Copy lib/core.lipl to a directory where the interpreter can find:

   • any directory listed in LIPLPATH environment variable
   • ~/.lipl directory

4.2   Quick Start

If you already have GHC and Cabal on your computer, you can quickly build and run the LIPL interpreter with following steps (*nix environment assumed):

shell> cd lipl #go to project root
shell> runhaskell Setup.lhs configure --prefix=/usr/local
shell> runhaskell Setup.lhs build
shell> runhaskell Setup.lhs install
shell> mkdir ~/.lipl
shell> cp /usr/local/share/Lipl-0.1/lib/core.lipl ~/.lipl
shell> lipl #assuming /usr/local/bin is in PATH
LIPL> (+ 1 2)
type: Int
3
LIPL> :q
bye
shell>

4.3   Requirements

To build and install the interpreter, a Haskell compiler is required. Since the project is a Cabal package, Cabal can be used to build and install the interpreter. Cabal is included in GHC version 6.8.* , so no separate installation for Cabal is needed.

4.4   Haskell Compiler

The interpreter can be compiled with GHC (the Glasgow Haskell Compiler) version 6.8.*. Other Haskell compilers or different GHC version might be able to compile the interpreter. But, only the specified GHC version is used to test the project.

Windows installer can be downloaded from http://haskell.org/ghc/download_ghc_682.html#windows .

After installing GHC, make sure the bin directory (probably C:\ghc\ghc-6.8.2\bin for Windows) is included in PATH environment variable so that ghc executable can be invoked from anywhere.

GHC comes with several executables:

ghc

compiles Haskell code to native binary. Example usage: ghc --make Main.hs

ghci

is an interactive Haskell interpreter.

runghc

interprets Haskell source code. Example usage: runghc Main.hs

runhaskell

same as runghc

4.5   Build

Building the project can be done in many ways.

shell> runhaskell Setup.lhs configure
shell> runhaskell Setup.lhs build
shell> runhaskell Setup.lhs install

shell> runhaskell Setup.lhs configure --prefix="C:\lipl"

shell> runhaskell Setup.lhs build
shell> runhaskell Setup.lhs install

4.6   Installation

Assuming lipl.exe is under C:\lipl\bin, add C:\lipl\bin to PATH environment variable so that you can start the interpreter from any directory.

The interpreter tries to find and load core.lipl (prelude library) that implements various useful functions. It searches core.lipl in following order:

1. current working directory
2. directories listed in LIPLPATH environment variable
3. in .lipl directory under HOME directory (C:\Users\yourid or C:\Documents and Settings\yourid)

core.lipl is can be found under lib directory, which is under project root (lipl/lib/core.lipl). So, copy it to a directory of your choice. Then set LIPLPATH environment variable to the directory where you copied core.lipl to. Or, copy core.lipl to C:\Users\yourid\.lipl\core.lipl (the directory C:\Users\yourid\.lipl is created when the interpreter is run for the first time).

4.7   Running the Interpreter

After finishing installation, you can type the following to start LIPL REPL (read eval print loop):

shell> lipl
LIPL>

At the LIPL> prompt, you can type LIPL expressions to evaluate them. Or, you can type :? to print help menu:

LIPL> :?
:? help
:s current type environment
:q quit
:e current environment
:c clear environment
:l <file> load <file>
:r <file> load <file> on clean environment

:s

prints types of currently available functions (type substitution environment)

:q

quits the repl

:e

prints identifiers and their values in the current environment. Built-in functions are not shown.

:c

cleans all bound identifiers. You are left with built-in functions only.

:l file.lipl

loads file.lipl . file.lipl should not define a function that is already in the environment.

:r file.lipl

cleans the environment first then loads file.lipl .

8.1   Parse

During parse phase, abstract syntax tree is built from string representation of a LIPL expression. The abstract syntax tree is represented with Haskell data structures. For example, (+ 1 2) is parsed into At pos (Expr [PrimFun "+", Int 1, Int 2]) where pos is source position (file name, line number, and column number) where the expression (+ 1 2) is located, and At, Expr, PrimFun, and Int are Haskell data constructors.

By recording source position with actual abstract syntax tree, better error message can be printed.

Actual implementation uses Parsec library that comes with GHC.

8.2   Type Inference

After successfully building abstract syntax tree from an expression, the tree is traversed and its type is inferred. Type inference makes sure ill-formed expressions are rejected before evaluation. For example, type inference phase fails to infer the type of (+ 1 'a') because the function + expects two Ints but a Char is passed to it.

Unification algorithm is used to infer type of each expression. Maintaining substitution (table of type variables and type expressions) and generation of new type variables are implemented in a custom monad.

8.3   Evaluation

Well-typed expressions are evaluated (normalized) in applicative order (eager evaluation). For example, both (g a) are evaluated then passed to function f, in (f (g a) (g a)).

Currying is implemented with closures. For example, (f a b) will be evaluated so that a closure is formed where the 1st formal parameter of f is bound to the actual parameter, a. Then, the closure is applied to the next actual parameter, b.

Evaluation is done inside a monad simulating a stack of environments: key value pairs where key is identifiers appearing in expressions and value is value bound to them.

8.4   Monad Transformer Library

Custom monads and monad transformers are written along with typeclasses to construct a monad (REPL monad) that can perform IO actions, type inference, evaulation, and error reporting. Type inference monad and evaluation monad (custom monads) are written in similar fashion as mtl monads are written, so that those monads can be combined with IO monad and error reporting monad (from base and mtl libraries that come with GHC) to construct the REPL monad used in the interpreter.