summary refs log tree commit diff stats
path: root/todo.txt
blob: 3c9754e10909166e19f20cb2945772e507270cbb (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
High priority (version 0.8.12)
==============================
* ``force_nosideEffect`` or some similar pragma is needed (``loophole``?)
* test threads on windows
* test thread analysis: 
  var x = globalString # ok, copied; `x` is mine!
  vs
  var x = globalRef # read access, `x` is theirs!

* 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``