This file contains an explanation of each of the
files used to parse and lex a file so it can be
evaluated with your Interpreter. You do not need
to edit these files, but they may be intresting
to look at.

1)	Debug.ml : This runs a series of simple tests
        for EvalEnv.ml.

2)	Error.ml (& Error.mli) : This contains the
	different types of exceptions and error
	handlers that are used in this language. 
	All errors are generated with this interface.

3) InfoSyntax.ml (& InfoSyntax.mli) : This contains
	the abstract syntax tree for type checking the
  expressions of this small language, as well as
  the representation of datatypes. It also contains
	other types and functions that make 
	evaluating expressions easier.

4)	Input.ml (& Input.mli) : This contains the
	interface that reads and parses expressions
	from files, input channels, and strings.

5) 	Lexer.mll : This breaks down a stream of
	characters into meaningful tokens that 
	can be used by the parser to build an 
	expression. Tokens keep track of their 
	original position in the stream so that
	the language can produce descriptive error
	messages with the Error interface.

6) 	Main.ml : This contains a simple interface
	that takes a file name as a command-line
	argument, parses the file to produce an
	expression, evaluates the expression in the
	file, and prints out the result of the 
	entire process to stdout.

7) 	Makefile : This file is intended to make
	the building of both Main.native and
	Debug.d.byte easier. To build Main.native,
	simply run the command "make" in your linux
	terminal window. To build Debug.d.byte, 
	simply run the command "make test" in your
	linux terminal window.

8) 	Parser.mly : This takes the tokens
	produced by the lexer and produces the
	appropriate expression.

9) Printing.ml (& Printing.mli) : This contains
	the interface for printing out expressions
	to stdout and for converting expressions
	to strings. This interface makes extensive
	use of OCaml's pretty-printing module.

10) Span.ml (& Span.mli) : This interface allows
	the language to keep track of the original position
	of each expression (and its subexpressions)
	in the stream of characters. This is used
	extensively throughout the language to help
	produce descriptive error messages with the
	Error interface.

11) Testfile.txt : This is a sample testfile that can be used
	when testing Main.ml. To use this file, simply type the 
	command "./Main.native Testfile.txt" after building
	Main.native. It should evaluate to 65.

12) Typing.ml (& Typing.mli) : This contains the interface that
	allows the language to typecheck each expression before
	attempting to evaluate it. This interface uses the Error
	interface to generate descriptive error messages if the
	expression (or any of its subexpressions) does not
	typecheck.

