TODO

For 0.2:
========

DONE - use s.ast.list methods for car/cdr etc primitives

DONE - fix dotted pairs + lists :-(
	- e.g. need to be able to parse (1 . (2 3)) correctly. and (1 2 . 3)

DONE - change s.ast.node.new to drop value

NOTNEEDED - have s.ast.list->[n] call ->nth(n)?
	- or make it is-a list with sugar?

NO - add autotests for list/pair interaction
	- make a list
	- take cddr of it
	- mutate the original list
	- check the taken value has mutated

DONE - drop ->value accessor?
	- have per-type accessor?
	- keep ->value for atom


- add macros
	DONE - add quasiquote to parser
	DONE - add quasiquote to evaluator
	DONE - add dotted pair to parser
	- add scheme-like dotted-pair to funargs
		- and factor out so can use for defmacro
	- add a pre-evaluation loop
		- skim top-levels, looking for defmacro
			- when found, install macro definition
		- loop top levels again, expanding macros in ast
			- loop until max N or no changes?
	- testing:
		- 'when' (if equivalent) (basic)
		- can implement 'delay' (evaluation order)
		- macro-in-macro
		- out-of-order macro-in-macro
		- inf recursive macro-in-macro should error?

DONE - mad Parse::RecDescent errors, but only when running under 'make test'
	- fixed by latest version of P::RD

- allow writing primitives (e.g. 'not') in scheme

- implement 'when' as a macro transforming to 'if'

- implement 'let' as a macro transforming to 'lambda'
	- consider deparse (maybe we need to give up on deparse?)
	- or provide properties on forms, so defmacro can stash original code
	- and quote can add a marker for deparse


==================================================

- lambda->invoke spins up a new evaluator. That's probably an error?

- allow doc strings

- get error text out of parse.recdescent + report
	- decorate AST with line number (and col?)?
	- throw exception

- write/grab some more examples
	- project euler?
	- compare output undef 'schip' and 'mzscheme -f'
		- correctness (stdout) and start measuring performance :-)
		DONE - compare as autotest

- remove some commonality in the numeric ops with a base class
	- implement in terms of 'fold'? 

- add (more) tests for recursion and (define (foo x) )

- design perl/scheme interop
	- could make use of sigils to call out to perl vars
		- or do we want more equivalence?
	- need oo support in scheme?
		- rip off arc/clojure?

- cleanup horrible hack of scalar return from parser->parse. Old code wanted one 'tree',
	newer code needs to know it can get back a list of trees (for full-parse of source file).
	Fix: search for '$tree.*=.*->parse'

- add boolean type and type coercion
	- #t and #f parse to s.ast.bool
	- is a bool a number? (No, you don't want addition etc)
	- coerce arg to 'if' to boolean
	- (or just add is_true method to s.ast?)

- add more numeric tower (complex and exact)?

- can we get as far as compiling lambdas to perl code?
	- they could install into the environment in the same way that the
	initially supplied primitives do