TODO

Autotools
  - Use mickey/$VERSION subfolders for
    - C++ include files
    - C++ library files
    - Scheme library files
  - Add man-pages
  - Add --with-xxx for optional libraries (SDL, gpg, etc.)
  - Installation to include/-folder lacks types subfolder.
  - Use libltdl to load plugins.
  - Make distcheck work correctly (the tests are broken as they are now)
  - Add more TAP tests
  - Fix TAP testing harness so I don't have to use run.sh and all that stuff.
    Would be best if I could simply do "TESTS = test1.scm test2.scm ..."
  - Make a separate (test tap) library. Rename (tap-results) to (tap-range) for
    instance.
  - Should be possible to add several paths to MICKEY_LIB, e.g. ="a:b:c"
  - Make install on /usr/local doesn't work.

BUGS

- (begin) should be exported by (scheme base), seems it's built-in to mickey.
  Also, it's not expanded by readline when doing (b<TAB>.

EQUAL?-EXACTNESS-BUG

> (equal? #e-17 #i-17) should return #f, because it should compare exactness as
well, but it doesn't.

IMPORT-BUG

(import (only (scheme base) display)) <== display is in (scheme write), so that
should be an error, but mickey silently ignores it.

IMMUTABLE STUFF

The (scheme eval) (environment) procedure should return an IMMUTABLE
environment. Currently, it's mutable (everything in Mickey is).

List print bug

> (cons 'a 'b) ==> a . b instead of (a . b)

REPL bug

#; mickey> 2 . 3
2
<runtime> Cannot evaluate: #<?unknown_type? 0x0>

TIME

Fix current-jiffy.
Add subsecond precision to current-second by using floats.

RECORDS

- Seems that defmacro and record-types do not work again,
  check HEAD^2

MAP / FOR-EACH

- More tests for *map, *for-each (map, string-map, vector-map, etc)
- nested maps, nested for-each, nested map/foreach

COND-EXPAND

Allow top-level, unimported cond-expand with a program switch.
For loading portable programs.

LAMBDA FORMALS

It should be an error to use the same variable name more than once in a
lambda formals list:

> (lambda (x x) x)

This works in mickey but should not.

DISJOINTNESS OF RECORD TYPES

Note that R7RS, chapter 3.2 says that "no object satisfies more than one of
the following predicates ... and all predicates create by
define-record-type".  So, it's not enough to have define-record-type use
compund-objects such as (list (list <record-name>) <data> ...) as it would
satisfy both pair? and <record-name-predicate>?. Fix this either by creating
an API from Mickey C to Scheme with access to the dynamic type system, or
similar.

PRINTER CONS BUG:

> (cons 1 2)

outputs "1 . 2" instead of "(1 . 2)". Fix it.

PRINTER STRING BUG:

> (display '("hey"))
(hey)

Should in fact print
("hey")

This works though:

> "hey"
"hey"

CDR-bug:

CDR should check if it's in fact a proper pair:

In mickey, this works:
> (cdr '())
In other schemes, it fails with an error "Not a pair"

IMPORT BUG

It's possible to export an identifier that's not bound, e.g.

(define-library (foo)
  (export foo bar)
  (begin
    (define foo 123)))

Here bar is exported but does not have a value. The import procedure should
raise an error in that sitaution; currently mickey does not.

MULTIPLY-BUG

(* 10.0 23/27)
<runtime> Cannot multiply integer with rational: 23/27

This should just be demoted to an inexact result, or

(* 10.0 23/27) --> (* 10.0 (inexact 23/27)) ==> 8.51852

DEFINE-BUG

Can actually do this:

(define '(scheme base) 123)

Define should check that its first argument is a symbol.

QUASIQUOTE BUG

Mickey doesn't allow nested quasiquotes:

`(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)

does not work.

From r7rs draft 9:

"""
Substitutions are made only for unquoted components appearing at the same
nesting level as the outermost quasiquote. 
"""

In mickey, I just parse along and eval anything that is unquoted.
By using a counter to keep track of current quotation level, one simply only
evals stuff at the outermost level (level=0).

ADD

Add delete-file to (scheme process-context)

CRASH

This crashes:

$ ./mickey -L.foo

segfault :)

PARSER BUG

Should not be allowed:

(lambda (. rest) 123)

csi and chibi does not parse the above; mickey segfaults.

OTHER STUFF

- remove unspecified(nil()), or make it possible to eval.. it evaluates to
  <?unknown ....?> so shouldn't be used (unspecified function can intercept
  NULLs and fix them?)

MORE BUGS:

- This parses
  > #\"
  but this doesn't:
  > #\" "foo"
  or, similarly,
  > (list #\" "foo")

- If (export ... foo ...) is specified, but no (define foo) exists,
  it should raise an error (or at least a warning).
  (must also check that foo is not imported; just check the environment).

- #(aa bb cc) produces vector, but
  '#(aa bb cc) does not; it produces the quoted list
  '(vector aa bb cc). It should produce an IMMUTABLE vector.

- parser error / Doesn't work:
  mickey> 0;
    but this works:
      mickey> 0 ;

- Does not check if it's got all arguments:
  (set-cdr! (cons 1 2))
  same with set-car! ?

BUGS

- Error in printing of vectors: `(list->vector '((a . b) (c . d) (e . f)))`
  should print `#((a . b) (c . d) (e . f))` but instead prints
  `#(a . b c . d e . f)`.

READER

- Add simple reader macros:
  - At least add a runtime possibility to inject a way to print
    and parse pointer-tagged types, so we can create a nice looking
    syntax for s64vector etc.

BINDING NULL-VALUES

- ((lambda (a) '()) (cdr '())) does not bind anything to a;
  an error should be explicitly signalled for this kind of case.

PROPER TAIL-RECURSION FOR APPLY

- Although this doesn't break:

  (define (a x)
    (a x))

  (a 1)

  ... this DOES: (define (a x)
                   (apply a x))

  because (apply) is not properly tail recursive.  So fix that.

LIBRARY

- Rename many of the (mickey ...) libraries to (system ...) to signify
  that many of them could potentially be portable interfaces to similar
  functionality elsewhere, but contains stuff that pertains to the given
  implementation system.

  Only keep things that are completely specific to Mickey Scheme in (mickey
  ...).

- Rewrite (define-library ...) as Scheme code using macro expansion and the
  support for first class environment.

- When exporting, check that definitions exist
  (now, we can specify (export foo) without having defined any foo,
   but that should be an error.. same with renames)

- Implement includable lib specs

- Add (portable zip), (portable reduce) / (portable fold) w/foldr foldl

- Allow (define ...) outside of (begin ...) blocks in (define-library ...)
  (note, doesn't seem like R7RS allows it)

- In lib/index.scm, do not include (library name) in list, just filenames,
  and build that index in-memory.

- Clean up the library index parser mess in src/import.cpp
  (move it to another file)

- For large libraries in lib/, split up into several files and use
  (include ...) forms.

FEATURES

- Add lib/index.scm that contains a list of libraries

BUGS

- The (when) macro is broken (or, the macro system is broken),
  doesn't work in code once you starting actually using it, like
    (define (catch-signal s) (when (eqv? s 'sigint) (display "hey")))
  does NOT work...
- (let loop (<pair>) ...) check that we have a (<pair>)
- Try s|...|# for a file, the parser will crash
- While (list #\) #\)) works, (list #\)#\)) does not.
- This causes segfault: (lambda (. rest) 1)
                        (lambda ( . rest) 1)

TESTS

- TODO: Make test that checks that '(lambda () 1 2) written to a
  string is indeed '(lambda () 1 2)

PARSER

- Suffices: 10e3 ==> 1000, 3.1415926535F0, etc.
- Make sure |\t\t| and |\x9;\x9;| are the same
- Add column numbers in parser

- Note that ignore-next-datum is treated like a token in Mickey,
  but probably not in other schemes:

  #; mickey> '(a b dee#;fee)
  (a b dee)

  Chicken-scheme (hmm, seems it handles this very early in the parsing):
  #;1> '(a b dee#;fee)
  )
  (a b dee#)

  EXACT same happens with Chibi.

LIBRARY: SCHEME BASE

- Complete (c stdio) and use it to implement various procedures in (scheme
  base) and other (scheme) libraries.  ==> move stuff out of scheme-base.cpp
  to scheme/base.scm

- In define-library export list, check that we actually DO have definitions
  for those that are listed.

- libscheme-base.so is both loaded dynamically and statically linked in via
  object files.  Move all eval-internal procs to this module and make it
  100% dynamically loaded.

- char=? should accept 2 or more parameters (same for most char*?
  predicates)


RANDOM STUFF

- "define" and friends should be exported by (scheme base), so that e.g.
  prefixing them with base: would mean you would have to do (base:define
  ...), so fix that.
- If backtrace() has only one entry in REPL, don't print it
- Create a library (mickey defmacro) with straight expansion, like
  (defmacro (my-unless condition body)
    `(if (not ,condition)
       (begin ,@body))) ; see what the function signature
       ; for defmacro is in norvig's jscheme
- See how MIT Scheme present first class environments to the user.
  Also see in the T book how they do it.
- In symbol(...), add assert_identifier(...) to check that we have a
  legal name for an identifier (e.g., no spaces, etc).  Could optionally
  also be done in the parser.
- For all functions, record arity somewhere (and, optionally, expected
  types), so that we can easily (and statically) detect errors.
- Lib: (scheme base) should refer to lib/scheme/base.scm
- eval() shold only intercept scheme core symbols, because of
  shadowing.
- Now that we have syntactic:bool in named_function_t, move functions
  from eval out to modules.
- In primitives.cpp symbol(...), don't seem to use environment to store
  symbols, meaning we have a global symbol table.  This should be in
  symbol-table.h or something like that, and should be fast(er) to
  lookup.  Also, remove the environment_t param from symbol("lala", e)
  since it's not needed.  Also, for string and symbol, it should suffice
  with pointer comparison with global tables.
- REPL: Add context-sensitive tab-completion, with double tab to cycle
  through alternatives.. e.g. (im<tab> -> (import and then
  (import (sch<tab> should give you (import (scheme, and then
  (import (scheme <tab>)) should give you a list of the scheme libraries.
- If we define identical symbols in two modules and import both, we should
  generate an appropriate error message.
- Rename module_blabla to module-blabla or library-blabla
- What happens if foo.scm contains (load "foo.scm") ? We should detect this.
- Should have a mutable list of internal and external lib names ("scheme
  base" . "base.scm" og externals_base)
- Create cxr.h and cxr.scm lib
- Does this work "#\ " (for space) ?
- Make current-*-port parameter-objects
- In {"make-string", proc_make_string}, use a struct to indicate if function
  should be syntactic so that args will not be evlis'ed
- Add func null_environment(int version = 7) that returns blank environment
  with only "import" defined
- Add func that returns typical repl environment
- If a C/.so scheme library contains some code in scheme form, then itself
  should be responsible to proc_load("file.scm") (so, we need a module api
  and init functions)
- ./mickey file.scm should have a completely empty environent except for
  (import), but eval has hardcoded some symbols, so fix that. (The way to do
  it is to move the core stuff into base library and mark the procedures as
  syntax (not normal syntax expand, but functions whose arguments are not
  evaluated)
- Fix (import) to handle multiple import statements (import (scheme base) (scheme write))
- Fix (import) to correctly exclude, rename, etc
- Make a C module system first, a la Python, with dynamic compiled
  libraries, to write a module you just include "mickey-api.h" and then
  you have cons and all that stuff and all the function signatures.
  Dynamically compiled modules must export name of library, symbols,
  etc and be fully compatible with the existing source level module
  system, etc.
- Add PORT type
- Add COMPLEX support
- For all cons cells, add bool constant field, enable for constant lists
  like '(foo bar
- Add full number format support in parser
- Add support for wide chars (wprintf, std::wstring, etc)
- Count linenumbers in parser and use that in exceptions (add filename and
  linenumber to exceptions as own fiels?)
- BUG: Cannot parse consecutive strings like "a""b""c"; the tokenizer should
       emit three tokens in that situation: "a", "b" and "c" to remedy the
       situation.  A good test that this is supported is to perform
       these tests:
       (length '(#;"a""b""c")) should return 2
       (length '("a"#;"b""c""d""e")) should return 4

List of what is most important to get a full r7rs system:
- call/cc, because lots of lib stuff depends on it
- proper syntax-rules with correct ... and :::, because
  many lib forms can use this for implementation
- correct module system, so that libs can be formalized

Other stuff:
-- This should be legal: (let ((=> #f)) (cond (#t => 'ok))) because of
   hygiene (see r7rs example on this, it should recognize => as a local
   variable and then allow its use)
-- Fiks at REPL viser '()
-- Fiks syntax match på bugs/macro4.scm
-- Fjern append() overalt det finnes
-- Lag SYMBOL-TABLE slik at ALLE symboler som har samme navn peker
   til samme globale symbol.
-- Lag enkel PRE-PARSER av kodesnutter som OVERSETTER (dvs enkel
   kompilering) feks alle slike symboler slik de peker på samme
   symbol, og at visse variabel-referanser ikke bruker lookup()
   men peker direkte med peker til variabelen som refereres osv.
   Dette er ganske safe optimaliseringer, men gjør at interpretation
   går mye raskere.

Now:
- repl> '() does not print anything, so fix that
- try to simplify print.cpp
- refactor the parser, extract methods into files (parse-string.cpp,
  parse-quotation.cpp etc) and add a table of tokens ("(", ")", "'", "#(",
  "#|", ...) etc and generally clean up

- BUG: (length (cons 1 2)) ==> 2 but should be an error

Fix 1:
#; mickey> (cons 1 2)
1 . 2

but should display (1 . 2).  See listp() and pairp(), and/or sprint.

Fix 2:

#; mickey> '(1. 2)
(1 2)

Should return (1 . 2) or the same as (cons 1 2).

- BUG: (cdr '(a . b)) should return (b) and not (. b)
- FEATURE: Support for let-syntax
- Quotation-parser is broken, e.g. can't do "Just say \"Yes!\" please"
- BUG, VARIADIC FUNCTIONS: Now I'm looking for the dot in the input
  arguments, but the CORRECT way of doing that is to let the reader
  translate a "first . rest" into "(cons first rest)" so we get an
  improper list.  This alleviates the need to handle dots, and will
  also make it easier system-wide to handle variadic functions (e.g.,
  in double macro invocation, variadic functions arguments will
  "expand" correctly).
- Support for non-syntax rules() define-syntax (if allowed in r7rs)
  (it just says "it SHOULD be syntax-rules")
- BUG: Detection of proper list/circular lists must be done in many lisp functions
- UTF8 support
- Think about constancy, like a quoted list like '(1 2 3). Should we mark it
  as constant?  What does the draft say about this?
- This '#(1 2 foo) parses to (quote (vector(1 2 foo))).  NOt sure if that's
  correct, or whether the ' just means it's a constant-vector
- Problem with "repl> '(1 . 3)" as it does not produce ONE pair with CAR->1
  and CDR->3.  But "(let ((v (list 1 2))) (set-cdr! v 3))" DOES produce a
  proper pair with CAR->1 and CDR->3.
- Allow #true and #false as #t and #f, but currently we can to #tfoo and
  #ffoo, so fix that
- Apparently, this is not allowed in r7rs: "1.2f" to donate floats, or "2f"
- Enforce rules for names of definitions. E.g., this is not ok: (define (1+ num) (+ 1 num))
- Regarding vectors passed to functions expecting lists, find out the
  exact differences... i.e., read up on vectors

* BUG: Should be false: (list? '(a . b)) but is true b/c "." is considered an atom
* BUG: Can't do negative modulus operations
* BUG: Should be true: mickey> (integer? 3.0)
* BUG: Can't parse complex number -2.5+0.0i
* BUG: Can't parse real number #e1e10
* BUG: Can't parse infix integer expression 8/4
* BUG: This must work: `(a `(b ,foo)) ==> (a (quasiquote (b (unquote * foo))))
* BUG: Hangs: mickey> 'a
* BUG: Unsupported: '#(1 2 3)
* BUG: N quotes should equal one: mickey> ''''a ; should be same as 'a
* BUG: Hairy implementation of mickey> '()
* BUG: Cannot parse #\) or #\(, e.g.: mickey> (display #\))
* BUG: Space "#\ " can work with ANY non-printable character in the last
       position, e.g. "#\<CTRL+V+TAB>" will also give a space.  This is because
       of the strange parser implementation
* BUG: Nested quasiquotation does not work (this works in guile): `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)
* BUG: Should be true: (real? 3) ==> #t but returns #f
* BUG: Macro system does not pattern match correctly -> see macro4.scm

- Reader notation for vectors: repl> #(1 2 3)
- Add third param to assoc, being the equality operator: (assoc 2.0 '((2 two) (3 three)) =)
- Add (string-ci=?)
- Add (list-set!)
- Add (inexact->exact)
- Add (make-list)
- Add (string->number <string> <opt2>), takes <opt2> option, (radix?)
- Add (call-with-values)
- Add (denominator)
- Add (numerator)
- Add (remainder)
- Add (exact?)
- Add (inexact?)
- Add (exact-integer?)
- Add (complex?)
- Add (letrec-syntax)
- Add (let-syntax) ; almost same as define-syntax, so should be asy
- Add ,@(...) support.  Same as ,(...) BUT it does not cons(...) its result
- Add (stream-filter)
- Add (make-parameter)
- Add (parameterize)
- Add (lazy) (didn't know this was a function?)
- Add (let*-values)
- Add (letrec*)
- Add "#(1 2 3)" -> "(make-vector 1 2 3)"
- Fix (delay) doesn't work properly; can do (define foo (delay (+ 1 2 3))) and then (foo) ==> 6, but that shouldn't evaluate.
- Add parsing of quoted vectors, i.e.: '#(1 2 3)
- Trampoline more stuff in eval()
- Add PROPER support for '()
- Add vector-map
- Add vector-for-each
- Add support for case-folding and other hash-bang stuff
- REPL: If expression hasn't been closed, wait for more lines.
- Add support for '#(1 2 3)
- Add support for '#u8(1 2 3)
- Add eqp() support for vectors
- Add eqp() support for pairs (lists)
- Run "(4 5)" and "(vector 1 2 (3 4))" works fine.  Fix in invoke().
- Fix TRY-CATCH jump implementation (TRY=excepation_raised()+goto)
- Update append() in primitives to be same as idiom in proc_vector_to_list.

RANDOM STUFF

NEXT STEPS, SHOULD BE ORDERED BY INCREASING DIFFICULTY
- Add module system (module, export, import, etc)
- Put as many functions as possible into the base module
- Add let-syntax
- Fix define-syntax / syntax rules: LOTS of bugs in the macro system
- Add more recognized patterns in syntax-rules
- Add letrec*
- Add let-values
- Add let*-values
- Fix native string type; using C-string doesn't work with make-string 10 #\nul
- Add simple mark-and-sweep GC (simple; currently not needed)
- Look into exact->inexact stuff
- Add continuation passing style (CPS) transform for all code
- Refactor the code, it's A MESS at the moment...
- Fix expt for fractional exponents
- Add support for continuations
- Add call/cc
- Add support for first class continuations
- Add memoization to lazy evaluation form
- Add UTF8 support for strings
- Add UTF8 support for define names (if allowed by r7rs)

LATER / HARDER
- Add library functions
- Add libffi support
- Add llvm primitives in scheme
- Craft llvm compiler (in scheme?)
- Add (fast) vector/SSE support through #(1 2 3)
- Add parallelization support (through some lib; see comp benchmarks game)

LLVM
Make all llvm primitives callable by interpreter, i.e.
implement functions as llvm primitives, e.g.:

  (define display
    (lambda (p)
      (while (not (null? p))
        (begin
          (if (not (pair? p))
            (ffi:printf "%s" (->c_string p))
            (display (eval (car p))))
          (set! p (cdr p))))))

Some functions must be built-in, I guess, like "no", "null?", "->c_string"
and so on.  But perhaps later on, these can as well become something that
can be implemented (?).  (At least many of them).



MISCELLANEOUS THOUGHTS

- boer ha en ny cons_t type som er cons_t-pointer, saa kan man slaa opp
  symbol i environment og sette den til aa peke paa cons_t-en som staar i
  mappen, men det krever vel egentlig at vi bruker map<symbol_t, value_t**>
  saa kan fekd (define a 123) (display a) endres til map<symbol_t,
  value_t**> <- "a", new value_t** <- new value_t*(123) saa blir (display a)
  altsaa (value_t** -> display, value_t** a) som peker rett inn i
  symbol-table.  (trenger vel ikke endre symboltable, den er som den er, men
  looked-up saker er cons_t** som peker til symbol table.

- lookup_symbols(program_t*) for aa slaa opp saant, kjoeres foer hvert
  program og bruker lexical scoping rules..  merk (define a 123) (display a)
  (set! a 456) funker fortsatt pga vi peker bare til riktig storage location
  direkte inn i symboltabellen.  dette boer gi en heftig speedup da vi ikke
  lenger trenger aa slaa opp ting med lookup() runtime.

- lag parser-bnf.cpp som er en recursive descent parser som
  direkte speiler informasjonen i r7rs draften om bnf.

- lag assert-symbol(a ...) som sjekker at hver sak lagt inn er
  symbol, brukes i feks base.scm

- Sjekk ut c++ muligheter for slikt: class value { value(int)...
  value(std::string).. value(float) osv og da value* proc(...) { return 123;
  } om det gaar an.  Problemet er pekerne og ikke eksplisitt oversetting,
  feks veldig mye hives inn som char-pointer, og float kan fint havne som
  int.. saa kanskje explicit constructors..  Fremdeles problem med pekerne,
  men hadde vaert nice.

- (begin ...) boer ikke extende environment, saa den maa interceptes paa en
  eller annen maate.. kanskje det er syntaktisk form og dermed ikke skal
  extende?  saan ideelt boer man ikke ha saa mange extends, dvs man boer ha
  1:1 forhold mellom antall env->outer hopp og scope-antall i kildekoden,
  saan at (let () let () <body>) har i <body> to env->outer, altsaa
  env->outer peker til foerste let og env->outer->outer peker til toplevel.