On Tuesday, 26 May 2015 at 14:59:38 UTC, Per Nordlöw wrote:
On Tuesday, 26 May 2015 at 10:19:52 UTC, Marc Schütz wrote:
... to be used in templates and for enforcing these rules:
http://wiki.dlang.org/User:Schuetzm/scope3#.40safe-ty_violations_with_borrowing
There's at least a plan. Nice!
One thing, though. I'm lacking a section in the document linked
above on how `foreach` could be `scope`-enhanced so that an
element reference of an aggregate doesn't escape its foreach
scope.
char[] saved_line;
string saved_str;
foreach (scope line; File("foo.txt").byLine)
{
saved_line = line; // should give error
saved_line = line.dup; // should be ok
saved_str = line.to!string; // should be ok
}
provided that `byLine` returns a reference to a volatile
internal buffer.
Assuming you mean by "volatile" that the buffer is released upon
destruction:
The compiler is supposed to do that automatically, i.e. `scope`
annotations on local variables are always inferred. In your
example, it would figure out that you're assigning a reference to
a value with shorter lifetime (i.e. the slice to the buffer) to a
value with longer lifetime (saved_line), which it would disallow.
(Btw, I don't think to!string is enough, because it is probably a
no-op in this case: string -> string).
However, byLine has another problem, which boils down to the same
cause as the problem with RCArray, namely that the content of the
buffer is reused in each iteration. The reason is that the
"owner" can be modified while references to it exist. For byLine,
this is not a safety violation, but for RCArray it is. A solution
applicable to both is to detect this and then either treat such a
situation as @system, or make the owner `const` as long as the
references are alive.
