On Saturday, 4 October 2014 at 19:26:01 UTC, Marc Schütz wrote:
On Saturday, 4 October 2014 at 19:22:45 UTC, Marc Schütz wrote:
On Saturday, 4 October 2014 at 18:13:03 UTC, Ivan Timokhin
wrote:
Also, would it really make much sense to track the owner
further than the assignment of a function's return value?
That seems to complicate things a lot by adding a hidden
attribute to a variable that is not only invisible at the
declaration (even though the full type is spelled out), but,
in fact, cannot be specified explicitly (because there's no
syntax for that, now that scope with owners is limited to
function signatures).
How about this:
---
scope(string) haystack, needle;
// next assignment is okay, because `s` is guaranteed not
to outlive
// `haystack`.
scope(string) s = findSubstring(haystack, needle);
// type of `s` is now scope(string), no additional
information
// attached
// so the next assignment is disallowed:
//needle = s; // error!
---
This could be unnecessarily limiting, but would it really
cause much trouble?
I think you're right, I thought about this after I replied to
you. It would be the logical next step. On the other hand, I
wouldn't want to lose const borrowing, because it turned out
to be a requirement for safe moving. But I think it can still
be tracked internally (owner tracking is necessary for
implementation anyway).
Owner tracking is then completely limited to one expression. I
think this will simplify the implementation a lot. Besides, it
has precedences: uniqueness is also only tracked inside an
expression, AFAIK.
... and value range propagation.
I've worked in the changes talked about so far, and I think I've
found a practicable solution for the forwarding problem. The idea
is to make the owner constraints (i.e. the things we declare in
function signatures) part of the type, but make types that only
differ in their constraints equivalent. This avoids template
bloat, but allows them to be forwarded where necessary. This is
at the cost of needing to spread this information outwards when a
template is going to be instantiated, which is however doable and
inexpensive, as the compiler needs to do a full analysis of the
template body anyway:
scope!haystack(string) findSubstring(
scope(string) haystack,
scope(string) needle
);
auto trace(alias func, Args...)(Args args) {
import std.conv : to;
writeln("Calling " ~ func.stringof ~
"(" ~ args.to!string ~ ")");
return func(args);
}
auto s = trace!findSubstring(haystack, needle);
// expands to:
scope!haystack(string) trace_findSubstring(
scope(string) haystack,
scope(string) needle
) {
import std.conv : to;
writeln("Calling findSubstring(" ~
args.to!string ~ ")");
return findSubstring(args);
}
Full proposal is here:
http://wiki.dlang.org/User:Schuetzm/scope
