skinny delegates

Steven Schveighoffer schveiguy at gmail.com
Mon Jul 30 21:02:56 UTC 2018


Would it be a valid optimization to have D remove the requirement for 
allocation when it can determine that the entire data structure of the 
item in question is an rvalue, and would fit into the data pointer part 
of the delegate?

Here's what I'm looking at:

auto foo(int x)
{
    return { return x + 10; };
}

In this case, D allocates a pointer on the heap to hold "x", and then 
return a delegate which uses the pointer to read x, and then return that 
plus 10.

However, we could store x itself in the storage of the pointer of the 
delegate. This removes an indirection, and also saves the heap allocation.

Think of it like "automatic functors".

Does it make sense? Would it be feasible for the language to do this? 
The type system already casts the delegate pointer to a void *, so it 
can't make any assumptions, but this is a slight break of the type system.

The two requirements I can think of are:
1. The data in question must fit into a word
2. It must be guaranteed that the data is not going to be mutated 
(either via the function or any other function). Maybe it's best to 
require the state to be const/immutable.

I've had several cases where I was tempted to not use delegates because 
of the allocation cost, and simply return a specialized struct, but it's 
so annoying to do this compared to making a delegate. Plus something 
like this would be seamless with normal delegates as well (in case you 
do need a real delegate).

-Steve


More information about the Digitalmars-d mailing list