todo.txt changes

todo.txt

@@ -1,12 +1,14 @@
 version 0.9.2
 =============
 
-- FFI:
-  * test libffi on windows
-  * test: times.format with the FFI
-- acyclic vs prunable; introduce GC hints
-- CGEN: ``restrict`` pragma + backend support; computed goto support
-- document NimMain and check whether it works for threading
+- make 'bind' default for templates and introduce 'mixin';
+  special rule for ``[]=``
+- ``=`` should be overloadable; requires specialization for ``=``; general
+  lift mechanism in the compiler is already implemented for 'fields'
+- mocking support with ``tyProxy`` that does: fallback for ``.`` operator
+  - overloading of ``.``? Special case ``.=``?
+- built-in 'getImpl'
+
 
 Bugs
 ====
@@ -28,18 +30,15 @@ version 0.9.4
 =============
 
 - macros as type pragmas
-- provide tool/API to track leaks/object counts
-- hybrid GC
-- use big blocks in the allocator
-- implement full 'not nil' checking
-- make 'bind' default for templates and introduce 'mixin';
-  special rule for ``[]=``
+- implement full 'not nil' checking; range[1..3] needs the same mechanism
 - implicit deref for parameter matching
-- ``=`` should be overloadable; requires specialization for ``=``; general
-  lift mechanism in the compiler is already implemented for 'fields'
 - lazy overloading resolution:
   * get rid of ``expr[typ]``, use perhaps ``static[typ]`` instead
   * special case ``tyStmt``
+- FFI:
+  * test libffi on windows
+  * test: times.format with the FFI
+- document NimMain and check whether it works for threading
 
 
 version 0.9.X
@@ -48,8 +47,6 @@ version 0.9.X
 - test&finish first class iterators:
   * nested iterators
 - implement the missing features wrt inheritance
-- object pooling support for *hard* realtime systems
-- improve the compiler as a service
 - better support for macros that rewrite procs
 - macros need access to types and symbols (partially implemented)
 - perhaps: change comment handling in the AST
@@ -62,8 +59,8 @@ version 0.9.X
   templates that would work too: T([.ref int])
 
 
-Concurrency
------------
+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 
@@ -83,21 +80,51 @@ Concurrency
 version 0.9.XX
 ==============
 
-- 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.
 - document nimdoc properly finally
 - 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
+- GC: implement simple generational GC
+  * first version: mark black in write barrier
+  * second version: introduce fake roots instead of marking black
+  * third version: find some clever heuristic which is preferable
+- 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; computed goto support
+- 'const' objects including case objects
+
+
 Not essential for 1.0.0
 =======================
 
-- 'const' objects including case objects
-- mocking support with ``tyProxy`` that does: fallback for ``.`` operator
-  - overloading of ``.``? Special case ``.=``?
 - 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.
@@ -108,28 +135,13 @@ Not essential for 1.0.0
 - ``with proc `+`(x, y: T): T`` for generic code
 - new feature: ``distinct T with operations``
 - arglist as a type (iterator chaining); variable length type lists for generics
-- resizing of strings/sequences could take into account the memory that
-  is allocated
-- codegen should use "NIM_CAST" macro and respect aliasing rules for GCC
 - implement marker procs for message passing
 - activate more thread tests
 - implement closures that support nesting of *procs* > 1
-- GC: implement simple generational GC
-  * first version: mark black in write barrier
-  * second version: introduce fake roots instead of marking black
-  * third version: find some clever heuristic which is preferable
 - object constructors: static check for fields if discriminator is known at 
   compile time
 
 
-GC
-==
-
-- precise stack marking; embrace C++ code generation for that
-- marker procs for Boehm GC
-- implement 'mixed' GC mode
-
-
 Optimizations
 =============