On 12/12/2011 01:50 PM, Steven Schveighoffer wrote:
On Sun, 11 Dec 2011 12:07:37 -0500, Mafi <m...@example.org> wrote:
Am 10.12.2011 21:25, schrieb Walter Bright:
On 12/10/2011 11:03 AM, Mehrdad wrote:
So how are you supposed to implement opApply on a container (or e.g.
here, a
matrix)? Copy/paste the code for const- and non-const versions?
Internal to a function, inout behaves like 'const'. You won't be able to
modify the data. Therefore, if there is no inout in the return type, use
'const' in the parameter list instead.
The purpose of inout is to transmit the 'constness' of the function
argument type to the return type, using only one implementation of that
function. That requires the function to internally regard inout as
const.
But what about:
void f(ref inout(int)* a, inout(int)* b) { a = b; }
This cant work with const because that would violate the const system.
I think the rule should be that either the return type must be inout
or at least one ref/out parameter.
Am I overlooking something?
That was brought up during discussion on adding the feature. One of the
reasons inout is viable is because a) the source and result of where the
constancy flows is well defined and b) the exit point is an rvalue
Allowing ref parameters fails both those rules.
Consider this:
void bad(ref inout(int)* a, ref inout(int)* b);
which is the entry and which is the exit? Is a set to b, or b set to a?
Now, also consider that you can't affect the constancy of the result,
because the type of the parameter is already defined. e.g.:
// note that your example shouldn't even be valid, because you can't
implicitly cast through two mutable references
int a;
auto pa = &a;
immutable int b;
auto pb = &b;
f(a, b);
How can this affect a? its type is already decided. Compare that to:
inout(int)* g(inout(int)* b) { return b;}
auto pa = g(pb);
clean and simple.
-Steve
This currently compiles:
inout(void) very_bad(ref inout(int)* a, ref inout(int)* b){a = b;}
void main(){
immutable int a=2;
int *x;
immutable(int)* y=&a;
very_bad(x,y);
*x=1;
assert(*y==a); // fail
}
How does the design catch this error? Will inout** = inout** assignments
be disallowed?
