TODO

- Ledgend:
  []      -- means TODO
  [?]     -- means partial implementation
  [X]     -- means done! (please remove from this file)
  [C]     -- means control flow related, see below
  [S]     -- means syntax-rules related
  [D]     -- means syntax-rules dependant
  [L]     -- means define-library related
  [R]     -- means research

- Numbers
  [X] arithmetic functions
  [?] trigonometric functions, TODO: must accept integers
  [?] type promotion [AJR]
  [?] number->string, TODO: optional parameters
  [] inexact->exact
  [] exact->inexact
  ---
  [] test suite [AJR]

- Syntax
  [X] (define-syntax)
  [X] (let-syntax)
  [?] (letrec-syntax), TODO: make recursive
  [?] syntax-error, TODO: differentiate from (error)
  [X] (syntax-rules)
  [] (syntax-case) -- low priority
  ---
  [X] Label these as [S] for syntax or [D] for dependant on syntax-rules
  [] research
  [] see if (define-record-type) can be derived syntax
  [] (a ...) works, but ((a b) ...) doesn't
  [] let loop -- this should be builtin

(let-syntax ((foo (syntax-rules () ((_) (list "foo"))))) (foo))
	=> '("foo")

- Control flow
  [] (call/cc)
  [] (dynamic-wind)
  [] (guard)
  [] (with-exception-handler)
  ---
  [X] Label these as [C] for control
  [?] raise-continuable -- may be revisited
  [] research


- Library support
  [] cond-expand
  [] define-library (R7RS)
  [] library (R6RS)
  [] import -- for programs
  ---
  [X] Label these as [L] for library
  [] research snow

- Record support
  [] define-record-type
  ---
  [] test suite

(define x 3)
(define-syntax foo (syntax-rules () ((foo) x)))
(define x 4)
(foo)

(/ (/ -1.0 0.0))
(define (assert x) (if x #t (error "Assert fail")))

- Hash Tables (from R6RS, and perhaps R7RS-large)
  [?] hashtable-mutable?, TODO: immutability
  [] list->hashtable -- equal? based
  [] vector->hashtable -- equal? based
  [] test suite [AJR]

- (scheme base) R7RS
  If you don't see the function here, then it means 
  that it's been implemented (at least partially)
  [C] call/cc
  [X] call/ec
  [D] case-lambda -- requires syntax-rules
  [L] cond-expand
  [R] define-record-type
  [L] define-library/library
  [D] do
  [C] dynamic-wind
  [C] guard
  [L] import -- for programs
  [X] parameterize
  [C] with-exception-handler

(cons i list)			a bcd
(list i i i i)			a b c d
(list* i i i list)		a b cd
(list+ list i i i)		ab c d
(listr list i)              	abc d
(append list list list)

(define (most ls)
  (if (null? ls) ()
      (if (null? (cdr ls)) ()
          (cons (car ls) (most (cdr ls))))))

(define (append a . rest)
    (if (null? rest) a
        (fold-right cons (apply append rest) a)))


(define (list* . rest)
  (if (list? rest)
      (apply apply list rest)))

(define (list+ a . rest)
  (if (list? a)
      (append a rest)))

(cons (car ls) (cdr ls)) == ls
(car (cons x y)) == x
(cdr (cons x y)) == y



- Guile compatibility
  [] 

- MIT-Scheme compatibility
  [X] rationalize->exact
  [X] simplest-rational->exact
  [X] simplest-rational

- Racket compatibility
  [X] andmap
  [X] ormap

- Other
  [] char-ci=?
  [X] empty?
  [X] inexact=?
  [X] pointer=?
  [] string-ci=?
  [X] symbol-ci=?
  [X] symbol=?
  [] make Seq interface

- List of dependancies

fold-left : case-lambda
fold-right : case-lambda
case-lambda : syntax-rules

- Macros

(and #t (begin (display "hello") #t))
(and #t (begin (display "hello") #f))
(and #f (begin (display "hello") #t))
(and #f (begin (display "hello") #f))

(define-macro (and . rest)
  `(if (null? (list ,@rest)) #t
       (if (car (list ,@rest))
           (and ,@(cdr (list ,@rest)))
           #f)))

(define-macro (or . rest)
  `(if (null? (list ,@rest)) #f
       (if (car (list ,@rest))
           #t
           (or ,@(cdr (list ,@rest))))))