To make functions definitions more expressive and give the compiler more
information to optimize I propose to make array function parameters
extendable with 'scope' such as follows:
size_t find(scope float[] haystack, float needle){ ... }
This would give the compiler the information that the array haystack
only has to be valid as long as the scope of the function find is valid.
As soon as the function scope is left, the array does not need to be
valid any more. This would greatly help when programming without a GC to
know, if the array one passes to the function will be saved internally
or if it only needs to be valid for the duration in which the function
is executed. Also it would allow the compiler to optimize array literals
such as:
find([1,2,3,4,5], 5)
The function call would not allocate on the heap, but would allocate the
array literal on the stack, as the compiler knows that is only has to be
valid for the scope of find.
Passing a scope array to another function which does not have the scope
annotation should be an error. Assining a a scope array to a non local
variable should be an error too. You could go really fancy on checking
scoped function parameters but for a start simple rules should be enough.
The same could be done with references and pointers. The purpose of this
would be to allow the compiler to do more static checking on the usage
of the passed arguments and make the function definitions contain
information if the passed references will be saved internally or not.
I do understand that non-gc programming is not considered often for the
D-Programming Language, but it would be nice if this idea does not get
ignored completely.
What do you think about this idea?
Kind Regards
Benjamin Thaut
