> > > I don't really have any good use-case examples. Maybe an initialization > > > function? Developed your own number object (big int) and were thinking > > > in terms of it being a refrence you thought > > > > > > a = a + BigInt(7); > > > > > > would result in a being resigned in the calling function. Or maybe just a > > > function that swaps two class references: > > > > > > void swap(T)(T a, T b) { // Correct void swap(T)(ref T a, ref T b) { > > > > > > auto tmp = a; a = b; b = tmp; > > > > > > } > > > > > > Actually that turned out to be a pretty good one. > > > > I do see why a = new A() is useful. But it makes only sense if I passed > > a/b as ref a/b. Basically I wonder why I do not get a warning when > > changing the reference in that situation. So my question is more why am > > I allowed to change the reference even though I didn't pass it as ref a. > > I was looking for a use of that. Assuming there is good use then there > > is no reason to forbid it. But if there is no good use I'd like to be > > warned when compiling the above swap. Because it's an error. > > For dynamic arrays slicing is a good example to allow it. But why should > > it be allowed for objects? > > Why wouldn't you be able to change it? You can change any parameter as long > as > it's not const or immutable (or in, which implies const). The fact that it's > a > referenc is irrelevant. I can assign whatever I want to references and > pointers > in a function whether they were passed in or not. Sure, if you want to alter > the > original pointer or reference, that's not going to work unless it was passed > as > ref, but that's the same as any other parameter. Why would you expect > altering > a reference to alter the original? Sure, altering what it _refers to_ should > alter what the original refers to because they refer to the same thing, but > altering the reference itself shouldn't alter the original because they're > two > different references. > > There is no reason why parameters should have to stay the same as what they > were > passed in as - regardless of whether they're value types or reference types. > If > you want that behavior, use const, in, or immutable.
I see your point. You argue that the behavior is consistent. My point is that this consistency can lead to bugs. I may forget the ref. But I'll keep in mind to never forget the ref if it is needed. Jens