Design and implement an interpreter for MicroHaskell programs. The interpreter should traverse the syntax tree and execute the statements of the program. The denotational semantics of MicroHaskell will assist you in constructing the interpreter. Your implementation should exactly follow the semantics. The interpreter will consist of the following components:

1. Construct a set of interpretation routines for each general root symbol in the syntax trees. For example, you need a routine to interpret the if statement, one for arithmetic operators, etc. Each interpretation routine will perform the actions specified in the semantics. For example, an if statement will evaluate the condition and then either the then or else part depending on whether the condition is true.

2. Some run-time type checking will be required, for example to distinguish list types from integers and to check the number of parameters being passed in functions. All such type checking is fully specified in the semantics. In the case of any errors, your interpreter need only print an appropriate error message and halt.

3. The result of executing a program is a type and value. You should output this when execution terminates.

4. In summary, your output should consist of the source program, local symbol tables and syntax trees for each function, and final output of the program being interpreted. If you implement your interpreter correctly, you should get the same output as the Haskell interpreter gives for the test programs (although the Haskell interpreter will execute programs which your interpreter will not).

Suggestion: Develop this incrementally over the following steps.

• Make your interpreter work first for expressions without declarations or function calls.
• Next handle declarations of variables and if-then-else expressions.
• Then handle expressions calling functions without parameters, including recursion.
• Lastly implement the function calls which involve parameter passing.