[HARD] -- hard to implement
[LOW]  -- have low priority
[???]  -- dunno if still true

- compiler stuff
  * conditional compilation
  * think about unicode strings [HARD]
  * add compiler switch to turn null-checking off [LOW]
  * assert
  * objects [HARD]
  * namespaces [HARD]
  * = "%identity", = "%word_0" etc
  * warning: "`foo' is assigned a value that is later never used"
  * unused globals warning doesn't work for self-recursive functions,
    nor for mutually recursive for that matter

- typechecker:
  * allow weak types in globals until end of compilation unit [HARD]

- cleanups:
  * split type.g, bind.g ?
  * use new language constructs ({} instead of ({}), [] for list
    construction, record copy with update etc)

- language:

- things that are known to be broken
  * floats in unions [???]

- 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. [HARD]
  * 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

# $Rev: 860 $ $LastChangedDate: 2002-09-02 09:14:56 +0200 (Mon, 02 Sep 2002) $
# vim:tw=75
