- big things to implement:
  * standard library (started)
  * conditional compilation

- other stuff
  * think about unicode strings
  * add compiler switch to turn null-checking off
  * assert

- things that are known to be broken
  * floats in unions (??)
  * complex pattern matching with exhaustive warnings

- typechecker:
  * implement full flagged type reconstruction

- possible optimizations:
  * if function doesn't pass its closure anywhere, we could allocate closure
    with alloca (or even simply put closure as variable on the stack), 
    which would be *a lot* faster. Similarly for passing lambda expressions
    just up the call stack. However this isn't as simple as it first seems.
    The problem is identifing such restricted functions (that don't need
    parameters beeing lambda expressions to be allocated on the heap).
    We would need to require user to annotate them somewhat in the
    interface file, which doesn't seem right.
  * try blocks could be stored in continuous fragment of memory, as they
    are added and removed in a LIFO way.
  * when calling top-level functions, not all arguments needs to be of
    pointer size (because auxiliary function needs to be generated anyway,
    if we want to use it as functional value), this is especially nice 
    to floats

- cleanups:
  * split codegen.g
  * make struct field names in ast.gi more uniform (esp. sym/symbol/name)


# $Rev: 543 $ $LastChangedDate: 2002-08-25 16:28:24 +0200 (Sun, 25 Aug 2002) $
# vim:tw=75
