TODO

Reductions (tree?)
lapply -> split vector?

To do list (not yet in priority order):

Big stuff
---------
-Garbage Collector. Replace Boehm with exact, generational garbage collector like everyone else has. Can we borrow the GC from a Javascript implementation?
-R external interface. Make it possible to load and use existing R packages.
-Class systems: S3, S4, R5 (can the implementation of these be simplified somehow?)
-Graphics support
-GUI (can we use existing R interfaces?)
-Debugger or profiler?

-Validate parser against R parser. Handle line breaks in some statements like R currently does. Handle multibyte strings (use iconv?) See list of open questions in lexer.rl

Incomplete language features
----------------------------
-on.exit, exceptions(?)
-next and break
-environment and call stack access functions (parent.env, sys.call, sys.parent, etc.)
-attribute access functions
-attribute propogation
-data frames
-matrix product, outer product, kronecker product operators
-Matching operator
-Help
-matrix indexing
-[[]] indexing (Works with a single index)
-character indexing
-search path
-S3 Classes
-S4 Class support (what's implemented in the library?)
	Generic functions as first class type?
-Computing on the language functions
-substitute
-FFI
-built in functions galore
-factors
-handle NAs in || and &&

Implemented, but needs testing and/or additional functionality
--------------------------------------------------------------
-... parameters
-argument names to built in functions
-$ indexing
-switch statement
-Incomplete parameter name matching.
	f <- function(x,y,index) {...}
	f(1,2,i=5)		# i should match parameter `index`
-$ indexing (Linear scan version done, but very slow. Can we store a map with a list or PIC?)
-eval
-warning, stop, on.exit, exceptions(?)
-NAs
-logical vector indexing
-negative number indexing
-complex numbers
-vector type conversion functions (as.*)

Language design issues
----------------------
-0-based indexing?
-Separate different indexing variants into distinct operators, e.g.
	a[c(0,1,2,3)]		selects elements 0..3
	a![c(0,1,2,3)]		selects all but elements 0..3
	Reasoning: deciding which to compute currently requires checking the index vector for positive and negative numbers. This revision would make that check unnecessary.
-Data frames as basic data type, necessary for DB-like query optimizations
-Richer type system, based on ADT? Represent NA in the type system.