Needed for version 0.3.0:

...and as part of 0.3.0:
* Remove functions deprecated before 0.3.0
* Remove old style exception handling; fix examples.
* Produce windows/MinGW binary distribution

Short term things to do:

* Shouldn't have a readline dependency (recommends is okay) on Windows
  if it can be avoided.
* Kind checking - if 'a' is used as kind *, it can't be used as kind
  *->*, etc. i.e., a<a> is broken; a foo(a<b> bar) is broken (since
  first a has kind *, second a has kind *->*); etc. Currently catches
  such errors elsewhere, but error messages aren't helpful.
* Go through all the functions in the standard library and run-time system and
  make sure there's no really silly mistakes, and that none of the TODO/FIXME
  areas are urgent.
* Add a -dumptypes debug option
* Dataflow analysis to identify non-interfering and inactive local
  variables, to reduce stack space usage and improve cache
  behaviour. Might be particularly effective at reducing intermediate
  variable usage in case analyses.
* Introductory section on the web page giving some nice code samples of
  kaya's main distinctive or useful (or both) features. (Pattern
  matching, some of the web bits like ability to pass closures around,
  symmetric encryption, list comprehensions, partial application). I always
  look for a page like this when I see a new language... It exists already,
  but it will need extending with new features and more code samples post-0.3
* Tidy up export lists in .hs files so that module interfaces are
  cleaner, rather than the current ad-hoc mess.
* Refactor Inference.hs, it's long and complicated and messy
* When lambda lifting, only add arguments to the lifted function which
  are used in the body of the lambda.
* Extra libraries for web development (not in stdlib)
* Big number primitives (BigInt/BigFloat)
* Improve compiler efficiency (look for tail recursion and strictness
  in particular - and profile!)
* If a module change doesn't change the contents of the .ki, don't
  rebuild dependencies.
* Finish hierarchical module system
* Think about a better module/package system (not necessarily to do
  anything about it, but at least think about it - consider dynamic linking)
* More data structure libraries (further to Queue, e.g. Stack, binary
  search Tree, generic Tree, Heap, Set, Graph)
* Redo testing framework - several separate categories
  - successful compile, successful run (sufficient coverage for all
    RTS).
  - successful compile, run-time error (covering all ways of throwing
    exceptions due to RTS errors)
  - fail to compile (covering all possible compile-time errors).
  - library tests (covering all stdlib functions).
  - regression (all the old errors, so that they don't come back).
* Implementation of infix operators relies too much on C. Add
  specialised VM instructions instead.
* Add op= shorthand for more operators.
* Performance tuning for library functions (in C if necessary).
  especially: Array::subarray, Array::remove, Array::take
* A script that syntax-highlights kaya source code, optionally using -dumptypes output to add type information.

Long term ideas:

* Consider subtyping/overloading.
* Reorganise parser.
* Tidy up Raw/Expr data types (big, boring job, so unlikely to happen).
* Identify pure functions for:
  + Inlining (making macros like #defines).
  + Common subexpression elimination.
* User defined optimisations via rewrite rules.
* Documenting the typing rules would be nice, if boring and unlikely
  to be read. A full formal description of the syntax too, which would
  also help in refactoring the parser.
* Switch to a register based VM, rather than stack based. (????)
* Self hosting!

Random thoughts

* Dynamic linking support would be nice.
