Le 18/06/2012 16:51, Andrei Alexandrescu a écrit :
Mehrdad posted a code sample and you replied to it with what I could
only assume was an explanation of the code's behavior. I hope you'd
agree it was a reasonable assumption, whether or not it was correct.
The problem at work here is that "this" is typed incorrectly during the
construction of a qualified object. It should go progressively from a
"raw" to a "cooked" state, and cannot be passed to any function while raw.
I've however made other posts to explain why
transitivity is broken when it comes to delegate.
I looked at your posts through June and couldn't find such, so a couple
of links would be great. Of course, bug reports would be even better!
I'm not sure you are talking about the proposal or the transitivity
issue here. I'll explain the proposal below, for the explaination of why
the transitivity is broken, see :
http://forum.dlang.org/thread/ywispsasaylqscyua...@forum.dlang.org?page=2#post-jrn7sv:24jjj:241:40digitalmars.com
To explain my proposal, I have to make several thing clear first. You
have here 2 things to qualify : the delegate itself, and the hidden
parameter. As type qualifier are transitive in D, qualify the delegate
also transitively qualify the hidden parameter.
The proposal was to use postfix qualifier notation to qualify the hidden
parameter, and qualifier between return type and delegate keyword to
qualify the delegate itself. My original proposal stated that the type
qualifier before the return type qualify the return type, but this is
another topic.
To make is clearer, some examples :
void delegate() const; // A mutable delegate that use const frame
pointer (all variable accessed throw the frame pointer are made const).
void const delegate(); // A const delegate that use a const frame
pointer (transitivity).
void const delegate() immutable; // A const delegate that use an
immutable frame pointer (delegate can only access immutable data from
the frame pointer).
void immutable delegate() const; // Error, immutable data cannot refers
to const data.
Note that the implicit cast goes the other way around than usual. void
delegate() const can be safely casted to void delegate(), but not the
other way around, as you are allowed to not mutate mutable data, but not
the other way around.
