WIP for Yellowstone trip
Missing Files for Yellowstone Trip WIP
Array Syntax Implimented

Arrays can be parsed and evaluated. There may still be some subtle bugs in
parser presedence with regard to index vs array literal.

The implimentation of the Array class is NOT included in this commit.
Framework for Adding Built in Class Functions

Classes with built in representations (i.e. String, Array, Hash, etc) need a
way to connect their internal functions into their Sapphire Class, and indeed
need to create and install their classes.  Doing so requires an active context;
that is it needs to occure after `boot` is called.

In the interest of keeping most initialization out of the main function, we
have chosen to add a single function, `__initialize`, to the installed
functions in Object.  This function is called before anything else in base.sap
and will initialize all the built in classes using their provided
initialization functions.

These functions have access to the a valid, though very limited, Context within
the EvalM monad.  They will need to create a new class and add it to Object
using low level functions.  This may become a place for refactoring.

Within this commit, Array is so initialized with a single function, `length`.
Addational function need to be added.
WIP home from vacation

In the process of writing library functions for Array
Foldable instance for Array

Arrays are now instance of `Data.Foldable`.  To accomplish this Arrays
needed to become true containers so a datatype Array` was created to hold
generic values and Array was redefined as an allias for an Array' holding
Values.

This should allow us to impliment the arrays built in traversal function
easily.
Array Internals Re-write

After much expirimentation and frustration implimenting arrays that
exibited O(1) behavior for indexing, I have come to the conclusion that
the performance given by the `Data.Sequence.Seq` datatype is sufficient
for Sapphire.

This has greatly simplified the implimentation of Array as it is now
merely a `Seq Value` with all the accompanying function from
`Data.Sequence` re-exported.

Basic indexing, itteration through inject, and length are now working.  At
this point it seems quite worthwhile to return to the main tree and
impliment function blocks which are quite handy when dealing with arrays.

Further Notes on Data.Sequence
==============================

Data.Sequence is an implimentation of 2-3 finger trees annotated with
sizes as described in Ralf Hinze and Ross Paterson, "Finger trees: a
simple general-purpose data structure", Journal of Functional Programming
16:2 (2006) pp 197-217. (Section 4.2)
http://www.soi.city.ac.uk/~ross/papers/FingerTree.html

Index operations are O(log(min(i,n-i))) that is, the operation takes
logrithmic with respect to the distance the element is from the edge of
the sequence.