Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

executable file 163 lines (130 sloc) 5.367 kB
version 0.8.14
- BUG: type TX = TTable[string, int]
- warning for implicit openArray -> varargs conversion
- implement explicit varargs; **but** ``len(varargs)`` problem remains!
--> solve by implicit conversion from varargs to openarray
- implicit invokation of `items`/`pairs` seems nice
version 0.9.0
- GC: marker procs for native Nimrod GC and Boehm GC; precise stack marking;
escape analysis for string/seq seems to be easy to do too;
even further write barrier specialization
- dead code elim for JS backend; 'of' operator for JS backend
- test the sort implementation again
- const ptr/ref
- unsigned ints and bignums; requires abstract integer literal type:
use tyInt+node for that
- implement the high level optimizer
- change overloading resolution
- implement closures; implement proper coroutines
- implement ``partial`` pragma for partial evaluation
- we need to support iteration of 2 different data structures in parallel
- make exceptions compatible with C++ exceptions
- ``=`` should be overloadable; requires specialization for ``=``
- 'const' objects including case objects
- os module should use Windows Unicode versions
- 64bit build for Windows
- change how comments are part of the AST
- optional indentation for 'case' statement; hm, keep in mind other syntax
changes that people want; may turn out to be a bad idea
- activate more thread tests
- optimize method dispatchers
- bug: generic assign still buggy
- special case the generic assign that needs to care about case objects
- bug: returning a tyVar does not mean it is save to return it:
proc forward[T](x: var T): var T = result = x
proc p(): var int =
var x: int
result = forward(x)
- bug: stress testing basic method example (eval example)
without ``-d:release`` leaks memory; good way to figure out how a
fixed amount of stack can hold an arbitrary number of GC roots!
version 0.9.XX
- implicit ref/ptr->var conversion; the compiler may store an object
implicitly on the heap for write barrier efficiency; better:
proc specialization in the code gen
- 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; tuple unpacking in non-var-context
- 'nimrod def': does not always work?
- test branch coverage
- checked exceptions
- make pegs support a compile-time option and make c2nim use regexes instead
per default?
- fix implicit generic routines
- improve docgen to use the semantic pass
- 'export' feature (requires improved docgen)
- think about ``{:}.toTable[int, string]()``
- mocking support with ``tyProxy`` that does:
o.p(x) --> p(o, x) --> myMacro(o, p, x)
This is really the opposite of ``tyExpr``:
* For parameter ``tyExpr`` any argument matches.
* Argument ``tyProxy`` matches any parameter.
- nice idea:
p(a, b):
echo a
echo b
is the same as:
p(a, b, proc() =
echo a
echo b)
- wrappers for poppler; libharu
- suffix trees
- locale support; i18n module
- bignums
- pdcurses bindings
- 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
- ``with proc `+`(x, y: T): T`` for generic code
- new feature: ``distinct T with operations``
- find a way for easy constructors and destructors; (destructors are much more
important than constructors)
- code generated for type information is wasteful
- resizing of strings/sequences could take into account the memory that
is allocated
- timeout for locks
- compilation cache:
- adapt thread var emulation to care about the new merge operation
- check for interface changes; if only the implemenation changes, no
need to recompile clients; er ... what about templates, macros or anything
that has inlining semantics?
- codegen should use "NIM_CAST" macro and respect aliasing rules for GCC
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: ``of`` 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``
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
- 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``
--> solved by providing an expr version of most control structures?
Jump to Line
Something went wrong with that request. Please try again.