http://d.puremagic.com/issues/show_bug.cgi?id=7543
--- Comment #6 from Boscop <kingbos...@gmail.com> 2012-03-09 14:27:43 PST ---
(In reply to comment #5)
> (In reply to comment #4)
> > (In reply to comment #3)
> > > We'll need a clear spec of what it means to have inout at two nesting
> > > levels of
> > > a function signature.
> >
> > This follows naturally from variance rules:
> > [snip.]
>
> I think you may misunderstand this issue.
>
> > Also the following subtyping rules for inout apply (R2 <: R1):
> > R2 delegate(inout(T)) <: R1 delegate(immutable(T))
> > R2 delegate(inout(T)) <: R1 delegate(const(T))
> > R2 delegate(inout(T)) <: R1 delegate(T)
> > And of course:
> > R2 delegate(inout(T)) <: R1 delegate(inout(T))
> >
> > From that follows (given two types A,B and B <: A):
> > B delegate(immutable(A)) <: A delegate(inout(A))
> >
>
> No, it does not. This is not sound.
>
> class A{immutable(A) get(){return null;}}
> class B:A{
> immutable(A) other;
> this(immutable(A) other){this.other = other;}
> override immutable(A) get(){return other;}
> }
>
> A delegate(inout(A)) dg = (immutable(A) a) => new B(a);
> A a = new A;
> A x=dg(a);
> immutable(A) b = x.get();
>
> // now a is mutable, b is immutable and (a is b).
Your example is unsound (no offense :)
You can't do:
A delegate(inout(A)) dg = (immutable(A) a) => new B(a);
and neither:
void function(inout(int)*) wfp = function(int*)(*p = 1;} // as you did in
comment 2 of bug 7542
1. as I wrote in bug 7542:
Given (R2 <: R1)
R2 delegate(inout(T)) <: R1 delegate(immutable(T))
(because of argument contravariance and immutable(T) <: inout(T)).
You can't assign an instance of a supertype to an instance of a subtype.
2. What do you expect from that func ptr? That you can assign a function that
takes mutable, const or immutable values as args?
You should not be allowed to assign a function that takes an immutable arg
because it assumes it won't be modified outside (and you could be passing in
mutable/const args)!
And you can't assign a function that takes a mutable because it could change
the const arg!
So you are left with being able to assign functions that take a const arg and
those that take an inout arg, because they can be substituted for the former.
Thats why you'd use a pointer to a function taking a const arg! (see bug 7542)
void function(const(int)*) wfp;
and then you can also assign a void function(inout(int)*)
You can call wfp with mutable, const and immutable args because as I wrote in
comment 4 of bug 7542:
T <: const(T)
immutable(T) <: const(T)
3. Aside from all the above, inout already has different semantics inside
function bodies, so it would be ambiguous to have another instance of inout in
a variable declaration because you can only refer to one constness (that of the
args of the current function).
Consider:
void main() {
class A {}
inout(A) foo(inout(A) a) {
inout(A) b = a; // inout already depends on a's constness
// can't introduce a different inout like you want here
inout(A) delegate(inout(A)) dg = (immutable(A) a) => new immutable(A);
return b;
}
foo(new A);
foo(new const(A));
foo(new immutable(A));
}
--
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
