High priority (version 0.8.12) ============================== * test threads on windows * test thread analysis: var x = globalString # ok, copied; `x` is mine! vs var x = globalRef # read access, `x` is theirs! * test message passing built-ins * make threadvar efficient again on linux after testing * document Nimrod's threads * document Nimrod's two phase symbol lookup for generics * bug: {:}.toTable[int, string]() version 0.9.0 ============= - add --deadlock_prevention:on|off switch? timeout for locks? - bug: tfFinal not passed to generic - bug: forward proc for generic seems broken - ``var T`` as a return type; easy to prove that location is not on the stack - test the sort implementation again - warning for implicit openArray -> varargs convention - implement explicit varargs - tests: run modules that contain "#RUN_ME", compile the other modules; run the GC tests - fix overloading resolution - make ^ available as operator - implement closures; implement proper coroutines Bugs ---- - bug: generic assign still buggy - Optimization: If we use a temporary for the result anyway the code gen should make use of this fact to generate better code... - special case the generic assign that needs to care about case objects version 0.9.XX ============== - distinct types for array/seq indexes - GC: marker procs for native Nimrod GC and Boehm GC; precise stack marking - implicit ref/ptr->var conversion; the compiler may store an object implicitly on the heap for write barrier efficiency - resizing of strings/sequences could take into account the memory that is allocated - typeAllowed() for parameters... - find a way to reintroduce the cleanup() pass for C code generation: this is hard because of partial evaluation --> symbol files will fix this as a side effect - EcmaScript needs a new and better code gen: simply adapt the C code gen to it - tlastmod returns wrong results on BSD (Linux, MacOS X: works) - nested tuple unpacking - 'nimrod def': does not always work? - test branch coverage - checked exceptions - fix implicit generic routines Library ------- - radix tree for strings; maybe suffix tree - locale support - bignums - ftp (and other internet protocols) - pdcurses bindings - queues additional to streams: have two positions (read/write) instead of one - for system: proc `@` [T](a: openArray[T]): seq[T] = newSeq(result, a.len) for i in 0..a.len-1: result[i] = a[i] --> ensure @[] calls the array version! Low priority ------------ - ``when T is int`` for generic code - ``when validCode( proc () )`` for generic code - find a way for easy constructors and destructors; (destructors are much more important than constructors) - code generated for type information is wasteful Version 2 ========= - language change: inheritance should only work with reference types, so that the ``type`` field is not needed for objects! --> zero overhead aggregation BETTER: ``is`` and safe object conversions only work with ref objects. Same for multi methods. - explicit nil types? * nil seq[int] * nil string * nil ref int * nil ptr THallo * nil proc - better for backwards compatibility: default nilable, but ``not nil`` notation: type PWindow = ref TWindow not nil The problem with ``nil`` is that the language currently relies on it for implicit initialization. Initialization is different from assignment. The issues can "easily" dealt with by ensuring: var x = myProc() # checks myProc() initializes every pointer explicitely - the two other parsers - generalized case statement (requires better transf) - rethink the syntax: distinction between expr and stmt is unfortunate; indentation handling is quite complex too; problem with exception handling is that often the scope of ``try`` is wrong and apart from that ``try`` is a full blown statement; a ``try`` expression might be a good idea to make error handling more light-weight people also want ``inc a; inc b``