04.10.2014 17:38, "Marc =?UTF-8?B?U2Now7x0eiI=?= <[email protected]>" пишет:
On Friday, 3 October 2014 at 19:08:10 UTC, Ivan Timokhin wrote:
29.09.2014 18:17, "Marc =?UTF-8?B?U2Now7x0eiI=?= <[email protected]>"
пишет:
...
Now, an idea that I have is that bare scope should be just a syntactic
sugar for self-owned scope; i.e., `scope(int*) x;` would be just a
short way of writing `scope!x(int*) x;`. This would imply that every
scoped variable has its own unique type, which is probably not that
terrible, considering that they can't be assigned freely to each other
either way. This is also somewhat more natural, because it means that
there is no such thing as just "scoped" variable, it is always
connected to a particular lifetime.
I've already suggested this as an implementation detail.
Sorry then, must have missed it.
>> ...
This of course has the unfortunate side effect of incredible template
bloat: For any distinct passed argument (which in practice means for
almost every call), we'd get a new template instance. IMO this is not
acceptable.
They could be merged in an executable, but a symbol table would be
cluttered. That does sound like a major issue.
As for passing unscoped strings to findSubstring, I see two alternatives:
1) Declare that all unscoped references are implicitly convertible to
scope!GC or something like that (and this conversion is used in such
cases). This one is probably better.
OTOH it would preclude automatic demoting of GC allocations to stack
allocations. And it would marry us to the GC is "default" allocation
strategy, which we might want to move away from (probably in favor of
generic allocators changeable at any point in time).
It doesn't necessarily have to be GC, just any object that we can safely
treat as an owner.
...
I think the key is in separating the scope attribute and the owner. The
former needs to be part of the type, the latter doesn't. In this vein,
it's probably a good idea to restrict the `scope!owner` syntax to
function signatures, where it may only refer to other parameters and
`this`. The use cases for it elsewhere are very marginal (if they exist
at all).
This naturally makes the return type of `findSubstring()` just
`scope(string)`; declaring a variable of it simply works:
typeof(findSubstring("", "")) s = findSubstring("Hello, world",
"world");
is equivalent to:
scope(string) s = findSubstring("Hello, world", "world");
This is a valid assignment, and owner propagation would even take care
of preserving the owners (though only on declaration, but that's natural
because the owners are only known at the call site):
string haystack, needle;
scope(string) s = findSubstring(haystack, needle);
// type of `s` is scope(string), owner is `haystack`
In other words, the type part of `scope!a(T)` is just `scope(T)`, the
owner is not part of the type and tracked separately.
That's ok with me (in fact, it looks very nice), but I think Manu's
point was that dealing with anything that isn't part of the type is
troublesome.
...
