intruducing null type as list's end
common value class introducing

A value class could be accessed by a `revo` program with being interpreted as
a data structure that could be used in revo program.

A value class must implement the following method, most of them are
already implemented by default:

    * initialize(*)
      contructor
    * atom?
      whether this object is an atom or a list?
    * list?
      *NO* need to rewrite this function, since it will take the
      opposite value from `atom?`
    * is_true?
      whether is object repesent true or false in a conditional expression
    * inspect
      used in debugging printing
    * to_s
      used for commonly outputing
    * eval(env)
      return itself for literals, and the evaled result for
      evaluatable values
done some TODOs for `-`, `*` and `/` operators
a fix in test file.
function alias support
adding rspec tests
Support for basic folding

new built-ins:
  * fold-left
  * fold-right

Reference: https://en.wikipedia.org/wiki/Fold_(higher-order_function)
compliting built-ins
more specs, for all current funcs
Merge pull request #3 from shouya/test

finished converting existing manual test cases into automatic ones
Naturally supported single variable in lambdas

According to the book:

The formal parameters defined by formals are bound to the actual
parameters as follows.

  *  If formals is a proper list of variables, e.g., (x y z), each
     variable is bound to the corresponding actual parameter. It is an
     error if too few or too many actual parameters are supplied.

  *  If formals is a single variable (not in a list), e.g., z, it is
     bound to a list of the actual parameters.

  *  If formals is an improper list of variables terminated by a
     variable, e.g., (x y . z), each variable but the last is bound to
     the corresponding actual parameter. The last variable is bound to
     a list of the remaining actual parameters. It is an error if too
     few actual parameters are supplied.

(http://www.scheme.com/tspl3/binding.html#./binding:h2)
Implemented quasiquote(unquote, unquote-splicing)

Perfectly done with it. All test cases are passed successfully. This
function works as good as GNU Guile*.

* The test cases are based on revo and guile, in which two it gives
  the same result.

`obj is equivalent to (quasiquote obj), ,obj is equivalent to (unquote
obj), and ,@obj is equivalent to (unquote-splicing obj). The
abbreviated forms are converted into the longer forms by the Scheme
reader (see read).

quasiquote is similar to quote, but it allows parts of the quoted text
to be "unquoted." Within a quasiquote expression, unquote and
unquote-splicing subforms are evaluated, and everything else is
quoted, i.e., left unevaluated. The value of each unquote subform is
inserted into the output in place of the unquote form, while the value
of each unquote-splicing subform is spliced into the surrounding list
or vector structure. unquote and unquote-splicing are valid only
within quasiquote expressions.

quasiquote expressions may be nested, with each quasiquote introducing
a new level of quotation and each unquote or unquote-splicing taking
away a level of quotation. An expression nested within n quasiquote
expressions must be within n unquote or unquote-splicing expressions
to be evaluated.

(See: http://www.scheme.com/tspl4/objects.html#./objects:h1)
Merge remote-tracking branch 'origin/dev' into dev
arranging directory structure
add revo binary
multi-expression support
revo interactive!
better interpretation for "and/or"
an improved interative repl interface

* support for lambda beside string as revi's prompt
* auto tab completion based on global variables
* friendly notification for users who don't know how to exit
Improved syntax rules for single expressions

The main purpose is for cope with the problem it made for built-in
user-defined functions that the old syntax regards 0..inf expr(s) as a
common multiple expressions.