On Monday, 9 February 2015 at 10:56:31 UTC, Dicebot wrote:
Doing a lot of porting from D1 to D2 recently I have realized
that we still don't have any idiomatic way to express function
result types that can be both mutable and immutable.
Consider this trivial snippet:
```D
import std.array : join;
void main()
{
auto s = join([ "aaa", "bbb", "ccc" ]);
pragma(msg, typeof(s));
}
```
It outputs "string" which stands for immutable buffer. However,
actual allocated buffer is not yet truly immutable - it has
just been allocated to hold the result of join algorithm and
may be interpreted both as mutable and immutable, depending on
caller desire.
In this specific case if caller wanted to get a mutable buffer
instead, it would need to do cast from immutable which is very
dangerous - especially considering implementation of `join` may
change. And doing .dup on buffer that has just been allocated
is quite a waste.
Right now I am leaning towards personal convention to always
return mutable or const buffers and do assumeUnique at caller
side where necessary. But this does, of course, suck.
What is current conventional wisdom on topic? Can we probably
start using std.typecons.Unique for such functions?
Someone is starting to see where I'm getting at when I'm pushing
for owned...
