On Tue, 07 Sep 2010 11:37:20 -0400, Pelle <pelle.mans...@gmail.com> wrote:
On 09/07/2010 04:33 PM, Steven Schveighoffer wrote:
Yes, a valid return. Your function should be:
void foo(void delegate(const(C) f) const
It helps to understand that inout/const/immutable has NOTHING to do with
code generation, it only has to do with limiting what compiles. For this
reason, an inout function is compiled once, and works on all three
constancies (4 if you have a nested inout function). For the entire
function any inout variable is treated as a non-changeable value, just
like const. Then when you return, it's converted at the call site back
to the constancy with which it was called. If the return value is void,
then there's nothing to convert, and no reason to use inout over const.
I'll repeat -- there is no benefit to inout if you are not returning
anything.
-Steve
That's not an equivalent function signature. Or maybe it is, but look at
this (sorry it's so long):
class C {
int x;
this(int y) { x = y; }
inout(int*) foo() inout {
return &x;
}
void bar(void delegate(int*) f) {
f(&x);
}
void bar(void delegate(const(int*)) f) const {
f(&x);
}
void bar(void delegate(immutable(int*)) f) immutable {
f(&x);
}
}
void main() {
immutable(int)* wah;
void wahwah(immutable(int*) x) {
wah = x;
}
auto c = new immutable(C)(10);
wahwah(c.foo); // why is this privilegied with inout
c.bar(&wahwah); // and this not?
writeln(*wah);
}
Can't use void delegate(const(int*)) there.
Thanks for clarifying, I didn't quite understand the usage before.
This is a limitation of inout's design. Technically inout requires a
single inout output, and can have multiple inout inputs. Your example
matches that description, so in theory it's possible.
But to simplify things, a function's only inout output must be on the
return value. So things like void fn(inout int* x, out inout(int) y)
don't qualify either.
IMO there is a whole host of implicit delegate casting that should be
possible, but isn't, including delegate contravariance. However, let's
get inout working as it's currently designed before we go relaxing the
requirements. I'm not a compiler/language designer, so I'm unsure if what
you want has any pitfalls.
-Steve
