On Sat, Nov 23, 2024, at 18:34, Rowan Tommins [IMSoP] wrote:
> On 23/11/2024 16:05, Rob Landers wrote:
>>> Your RFC doesn't discuss this - the changeName example shows behaviour
>>> *inside* the method, but not behaviour when *calling* it
>>
>> An interesting observation, can you explain more as to what you mean?
>
> Looking closer, there's a hint at what you expect to happen in your Rectangle example:
>
>
>
> $bigRectangle = $rectangle->resize(10, 20);
> assert($bigRectangle !== $rectangle); // true
>
>
> It seems that modifications to $this aren't visible outside the method, creating a purely
> local clone, which would be discarded if it wasn't returned (or saved somewhere).
>
> I can see the logic, but the result is a bit unintuitive:
>
>
>
> data class Example {
> public function __construct(public int $x) {}
> public function inc(): void {
> $this->x++;
> }
> }
> $foo = new Example(0);
> $foo->x++;
> $foo->inc();
> echo $foo->x; // 1, not 2
>
>
Interesting! I actually found it to be intuitive.
Think of it like this:
function increment(array $array) {
$array[0]++;
}
$arr = [0];
increment($arr);
echo $arr[0]; // is 0
We don't expect $arr to be any different outside of the function because $arr is a value, not a
reference. "data classes" are "values" and not references to values, thus when
you modify $this, you modify the value, and it doesn't affect values elsewhere. If you want to
keep track of that value, you have to put it somewhere where you can reference it—a return value,
global variable, property in a regular class, etc. In any case, lets keep going to see if there is a
better way.
> I think it would be clearer to prevent direct modification of $this:
>
>
>
> data class Example {
> public function __construct(public int $x) {}
> public function inc(): void {
> $this->x++; // ERROR: Can not mutate $this in data class
> }
> public function withInc(): static {
> $new = $this; // explicitly make a local copy of $this
> $new->x++; // copy-on-write separates $new from $this
> return $new;
> }
> }
>
>
Not that I disagree (see the records RFC), but at that point, why not make data classes implicitly
readonly?
>
>
> That would still be compatible with Ilija's suggestion, which was to add special
> "mutating methods":
>
>
>
>
> data class Example {
> public function __construct(public int $x) {}
> public mutating function inc(): void {
> $this->x++;
> }
> }
> $foo = new Example(0);
> $foo->x++;
> $foo->inc!(); // copy-on-write triggered *before* the method is called
> echo $foo->x; // 2
>
>
I actually find this appealing, but it is strange to me to allow this syntax on classes. Is there
precedent for that? Or is there a way we can do it using "regular looking PHP"; or are
structs the way to go?
Another alternative would be that mutations still trigger a copy-on-write, but the outer variable is
updated with $this upon return. So this would work:
data class Example {
public function __construct(public int $x) {}
public function inc(): void {
$this->x++;
}
}
$foo = new Example(1);
$bar = $foo;
$foo->inc(); // foo is copied on mutation, and $foo points at the new value on return.
echo $bar->x; // 1
echo $foo->x; // 2
To me, this seems like it would be even more intuitive; $foo has the value you would expect from
outside the class and doesn't require you keeping track of the value yourself. Though, there
are some footguns here too:
class Foo {
Example $bar;
function baz() {
$bar = $this->bar; // should be $bar = &$this->bar
$bar->inc();
echo $this->bar->x; // not incremented
}
}
I could go either way on this one, honestly; so it makes sense to me why structs would have a
dedicated syntax for whichever you prefer. On the one hand, it currently requires you to be explicit
all the time (which can be annoying), and on the other hand, there's the implicit copy here,
which requires you to be explicit when you want a reference.
I suppose there is a third option as well, and that is to not to any of these options and just have
data classes that always compare by value.
> ??--
> Rowan Tommins
> [IMSoP]
— Rob