version 0.9.6
=============

Concurrency
-----------

- document the new 'spawn' and 'parallel' statements
- implement 'deepCopy' builtin
- implement 'foo[1..4] = spawn(f[4..7])'
- the disjoint checker needs to deal with 'a = spawn f(); g = spawn f()'
- support for exception propagation
- Minor: The copying of the 'ref Promise' into the thead local storage only
  happens to work due to the write barrier's implementation
- 'gcsafe' inferrence needs to be fixed
- implement lock levels --> first without the more complex race avoidance


Misc
----

- fix the bug that keeps 'defer' template from working
- make '--implicitStatic:on' the default
- fix the tuple unpacking in lambda bug
- make tuple unpacking work in a non-var/let context
- special rule for ``[]=``
- ``=`` should be overloadable; requires specialization for ``=``; general
  lift mechanism in the compiler is already implemented for 'fields'
- built-in 'getImpl'
- type API for macros; make 'spawn' a macro
- markAndSweepGC should expose an API for fibers
- prevent 'alloc(TypeWithGCedMemory)'


Bugs
====

- bug: 'type T = ref T' not recognized as illegal recursion
- bug: type conversions concerning proc types are weird
- compilation of niminst takes way too long. looks like a regression
- docgen: sometimes effects are listed twice
- 'result' is not properly cleaned for NRVO --> use uninit checking instead
- blocks can "export" an identifier but the CCG generates {} for them ...


version 0.9.x
=============

- pragmas need 'bindSym' support
- pragmas need re-work: 'push' is dangerous, 'hasPragma' does not work
  reliably with user-defined pragmas
- memory manager: add a measure of fragmentation
- implement 'bits' pragmas
- we need a magic thisModule symbol
- provide --nilChecks:on|off
- fix closures/lambdalifting
- ensure (ref T)(a, b) works as a type conversion and type constructor
- optimize 'genericReset'; 'newException' leads to code bloat
- stack-less GC
- implicit deref for parameter matching

- VM: optimize opcAsgnStr


version 0.9.X
=============

- macros as type pragmas
- lazy overloading resolution:
  * special case ``tyStmt``
- FFI:
  * test: times.format with the FFI
- document NimMain and check whether it works for threading
- 'quote' without 'do' doesn't work: parser/grammar issue; could be supported


version 0.9.X
=============

- implement the missing features wrt inheritance
- better support for macros that rewrite procs
- macros need access to types and symbols (partially implemented)
- enforce 'simpleExpr' more often --> doesn't work; tkProc is
  part of primary!
- the typeDesc/expr unification is weird and only necessary because of
  the ambiguous a[T] construct: It would be easy to support a[expr] for
  generics but require a[.typeDesc] if that's required; this would also
  allow [.ref T.](x) for a more general type conversion construct; for
  templates that would work too: T([.ref int])


Concurrency/Effect system
=========================

- shared memory heap: ``shared ref`` etc. The only hard part in the GC is to
  "stop the world". However, it may be worthwhile to generate explicit 
  (or implicit) syncGC() calls in loops. Automatic loop injection seems
  troublesome, but maybe we can come up with a simple heuristic. (All procs
  that `new` shared memory are syncGC() candidates... But then 'new' itself
  calls syncGC() so that's pointless.) Hm instead of an heuristic simply
  provide a ``syncgc`` pragma to trigger compiler injection --> more general:
  an ``injectLoop`` pragma
- 'writes: []' effect; track reads/writes for shared types
- use the effect system for static deadlock prevention and race detection
- ``~`` operator for effects
- introduce 'noaddr' pragma to prevent taking the address of a location; this
  is very handy to prevent aliasing of global data


version 0.9.XX
==============

- make 'clamp' a magic for the range stuff
- better type syntax for functions and tuples: tuple(int, int); (int,int)->int


Memory safety
=============

- object branch transitions from low(selector) are unsafe! ---> Needs a 
  deprecation path
- object branch transitions can't work with the current 'reset'; add a 'reset'
  with an additional parameter --> simple:
  provide a 'reset(x, TObj(k: nkValue))' instead? why bother? '=' does the
  same.
- returning 'var T' is unsafe and needs some static analysis


GC
==

- precise stack marking; embrace C++ code generation for that
- marker procs for Boehm GC
- hybrid GC
- acyclic vs prunable; introduce GC hints
- use big blocks in the allocator
- object pooling support for *hard* realtime systems
- provide tool/API to track leaks/object counts
- resizing of strings/sequences could take into account the memory that
  is allocated


CGEN
====
- codegen should use "NIM_CAST" macro and respect aliasing rules for GCC
- ``restrict`` pragma + backend support
- 'const' objects including case objects


Not essential for 1.0.0
=======================

- allow implicit forward declarations of procs via a pragma (so that the
  wrappers can deactivate it): better solution: introduce the notion of a 
  'proc section' that is similar to a type section.
- implement the "snoopResult" pragma; no, make a strutils with string append
  semantics instead ...
- implement "closure tuple consists of a single 'ref'" optimization
- optimize method dispatchers
- new feature: ``distinct T with operations``
- arglist as a type (iterator chaining); variable length type lists for generics
- implement marker procs for message passing
- implement closures that support nesting of *procs* > 1
- object constructors: static check for fields if discriminator is known at 
  compile time
- prove array accesses


Optimizations
=============

- optimize 'if' with a constant condition --> necessary in frontend for better
  dead code elimination; also necessary to prevent  ``if c > 0: 1 div c``
- escape analysis for string/seq seems to be easy to do too;
  even further write barrier specialization
- inlining of first class functions
- proc specialization in the code gen for write barrier specialization
- VM/optimizer: implement on the fly CSE