Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:126039
Feedback-ID: ifab94697:Fastmail
Precedence: bulk
MIME-Version: 1.0
Date: Sat, 23 Nov 2024 21:27:15 +0100
To: internals@lists.php.net
Message-ID: <3e4506d7-227e-4521-a0c8-68e71fdc42a1@app.fastmail.com>
In-Reply-To: <2c286462-a9ac-4b12-89bf-aea66680dea0@rwec.co.uk>
References: <18b85ba5-5f1c-489c-9096-3ae203977fbe@app.fastmail.com>
 <163a08c1-2279-4a3f-a1bb-8cdfe406a4ba@rwec.co.uk>
 <0b87a3eb-7e63-4e28-a11d-25824e240a73@app.fastmail.com>
 <2c286462-a9ac-4b12-89bf-aea66680dea0@rwec.co.uk>
Subject: Re: [PHP-DEV] [RFC] Data Classes
Content-Type: multipart/alternative;
 boundary=af76a5a65d02442494fa1a85e9edd141
From: rob@bottled.codes ("Rob Landers")

--af76a5a65d02442494fa1a85e9edd141
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable

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 behavio=
ur
>>> *inside* the method, but not behaviour when *calling* it
>>=20
>> An interesting observation, can you explain more as to what you mean?
>=20
> Looking closer, there's a hint at what you expect to happen in your Re=
ctangle example:
>=20
>=20
>=20
> $bigRectangle =3D $rectangle->resize(10, 20);
> assert($bigRectangle !=3D=3D $rectangle); // true
>=20
>=20
> 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 r=
eturned (or saved somewhere).
>=20
> I can see the logic, but the result is a bit unintuitive:
>=20
>=20
>=20
> data class Example {=20
>    public function __construct(public int $x) {}
>    public function inc(): void {
>      $this->x++;
>   }
> }
> $foo =3D new Example(0);
> $foo->x++;
> $foo->inc();
> echo $foo->x; // 1, not 2
>=20
>=20

Interesting! I actually found it to be intuitive.

Think of it like this:

function increment(array $array) {
  $array[0]++;
}

$arr =3D [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 r=
eferences to values, thus when you modify $this, you modify the value, a=
nd 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=E2=80=94=
a return value, global variable, property in a regular class, etc. In an=
y case, lets keep going to see if there is a better way.

> I think it would be clearer to prevent direct modification of $this:
>=20
>=20
>=20
> data class Example {=20
>    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 =3D $this; // explicitly make a local copy of $this
>       $new->x++; // copy-on-write separates $new from $this
>       return $new;
>    }
> }
>=20
>=20

Not that I disagree (see the records RFC), but at that point, why not ma=
ke data classes implicitly readonly?

>=20
>=20
> That would still be compatible with Ilija's suggestion, which was to a=
dd special "mutating methods":
>=20
>=20
>=20
>=20
> data class Example {
>     public function __construct(public int $x) {}
>     public mutating function inc(): void {
>         $this->x++;
>     }
> }
> $foo =3D new Example(0);
> $foo->x++;
> $foo->inc!(); // copy-on-write triggered *before* the method is called
> echo $foo->x; // 2
>=20
>=20

I actually find this appealing, but it is strange to me to allow this sy=
ntax on classes. Is there precedent for that? Or is there a way we can d=
o it using "regular looking PHP"; or are structs the way to go?

Another alternative would be that mutations still trigger a copy-on-writ=
e, but the outer variable is updated with $this upon return. So this wou=
ld work:

data class Example {
   public function __construct(public int $x) {}
   public function inc(): void {
     $this->x++;
  }
}

$foo =3D new Example(1);
$bar =3D $foo;
$foo->inc(); // foo is copied on mutation, and $foo points at the new va=
lue on return.
echo $bar->x; // 1
echo $foo->x; // 2

To me, this seems like it would be even more intuitive; $foo has the val=
ue you would expect from outside the class and doesn't require you keepi=
ng track of the value yourself. Though, there are some footguns here too:

class Foo {
  Example $bar;

  function baz() {
    $bar =3D $this->bar; // should be $bar =3D &$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 c=
an 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.

> ??--=20
> Rowan Tommins
> [IMSoP]

=E2=80=94 Rob
--af76a5a65d02442494fa1a85e9edd141
Content-Type: text/html; charset=utf-8
Content-Transfer-Encoding: quoted-printable

<!DOCTYPE html><html><head><title></title><style type=3D"text/css">p.Mso=
Normal,p.MsoNoSpacing{margin:0}</style></head><body><div>On Sat, Nov 23,=
 2024, at 18:34, Rowan Tommins [IMSoP] wrote:<br></div><blockquote type=3D=
"cite" id=3D"qt" style=3D""><div class=3D"qt-moz-cite-prefix">On 23/11/2=
024 16:05, Rob Landers wrote:<br></div><blockquote type=3D"cite" cite=3D=
"mid:0b87a3eb-7e63-4e28-a11d-25824e240a73@app.fastmail.com"><blockquote =
type=3D"cite"><div>Your RFC doesn't discuss this - the changeName example=
=0A          shows behaviour<br></div><div>*inside* the method, but not =
behaviour when *calling* it<br></div></blockquote><div><br></div><div>An=
 interesting observation, can you explain more as to what=0A        you =
mean?<br></div></blockquote><div><br></div><p>Looking closer, there's a =
hint at what you expect to happen in=0A      your Rectangle example:<br>=
</p><p><br></p><div>$bigRectangle =3D $rectangle-&gt;resize(10, 20);<br>=
</div><div> assert($bigRectangle !=3D=3D $rectangle); // true<br></div><=
p><br></p><p>It seems that modifications to $this aren't visible outside=
 the=0A      method, creating a purely local clone, which would be disca=
rded if=0A      it wasn't returned (or saved somewhere).<br></p><p>I can=
 see the logic, but the result is a bit unintuitive:<br></p><p><br></p><=
div>data class Example { <br></div><div> &nbsp;&nbsp; public function __=
construct(public int $x) {}<br></div><div> &nbsp;&nbsp; public function =
inc(): void {<br></div><div> &nbsp;&nbsp;&nbsp;&nbsp; $this-&gt;x++;<br>=
</div><div> &nbsp; }<br></div><div> }<br></div><div> $foo =3D new Exampl=
e(0);<br></div><div> $foo-&gt;x++;<br></div><div> $foo-&gt;inc();<br></d=
iv><div> echo $foo-&gt;x; // 1, not 2<br></div><p><br></p></blockquote><=
div><br></div><div>Interesting! I actually found it to be intuitive.<br>=
</div><div><br></div><div>Think of it like this:<br></div><div><br></div=
><div>function increment(array $array) {<br></div><div>&nbsp; $array[0]+=
+;<br></div><div>}<br></div><div><br></div><div>$arr =3D [0];<br></div><=
div>increment($arr);<br></div><div>echo $arr[0]; // is 0<br></div><div><=
br></div><div>We don't expect $arr to be any different outside of the fu=
nction because $arr is a value, not a reference. "data classes" are "val=
ues" and not references to values, thus when you modify $this, you modif=
y 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 referen=
ce it=E2=80=94a return value, global variable, property in a regular cla=
ss, etc. In any case, lets keep going to see if there is a better way.<b=
r></div><div><br></div><blockquote type=3D"cite" id=3D"qt" style=3D""><p=
>I think it would be clearer to prevent direct modification of=0A      $=
this:<br></p><p><br></p><div>data class Example { <br></div><div> &nbsp;=
&nbsp; public function __construct(public int $x) {}<br></div><div> &nbs=
p;&nbsp; public function inc(): void {<br></div><div> &nbsp;&nbsp;&nbsp;=
&nbsp;&nbsp; $this-&gt;x++; // ERROR: Can not mutate $this in data class=
<br></div><div> &nbsp;&nbsp; }<br></div><div> &nbsp;&nbsp; public functi=
on withInc(): static {<br></div><div> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $ne=
w =3D $this; // explicitly make a local copy of $this<br></div><div> &nb=
sp;&nbsp;&nbsp;&nbsp;&nbsp; $new-&gt;x++; // copy-on-write separates $ne=
w from $this<br></div><div> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return $new;<=
br></div><div> &nbsp;&nbsp; }<br></div><div> }<br></div><p><br></p></blo=
ckquote><div><br></div><div>Not that I disagree (see the records RFC), b=
ut at that point, why not make data classes implicitly readonly?<br></di=
v><div><br></div><blockquote type=3D"cite" id=3D"qt" style=3D""><p><br><=
/p><div>That would still be compatible with Ilija's suggestion, which was=
=0A      to add special "mutating methods":<br></div><p><br></p><p><br><=
/p><div>data class Example {<br></div><div> &nbsp;&nbsp;&nbsp; public fu=
nction __construct(public int $x) {}<br></div><div> &nbsp;&nbsp;&nbsp; p=
ublic mutating function inc(): void {<br></div><div> &nbsp;&nbsp;&nbsp;&=
nbsp;&nbsp;&nbsp;&nbsp; $this-&gt;x++;<br></div><div> &nbsp;&nbsp;&nbsp;=
 }<br></div><div> }<br></div><div> $foo =3D new Example(0);<br></div><di=
v> $foo-&gt;x++;<br></div><div> $foo-&gt;inc!(); // copy-on-write trigge=
red *before* the method is=0A      called<br></div><div> echo $foo-&gt;x=
; // 2<br></div><p><br></p></blockquote><div><br></div><div>I actually f=
ind this appealing, but it is strange to me to allow this syntax on clas=
ses. 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?<br></div><div><br></=
div><div>Another alternative would be that mutations still trigger a cop=
y-on-write, but the outer variable is updated with $this upon return. So=
 this would work:</div><div><br></div><div>data class Example {<br></div=
><div>&nbsp;&nbsp; public function __construct(public int $x) {}<br></di=
v><div>&nbsp;&nbsp; public function inc(): void {<br></div><div>&nbsp;&n=
bsp;&nbsp;&nbsp; $this-&gt;x++;<br></div><div>&nbsp; }<br></div><div>}<b=
r></div><div><br></div><div>$foo =3D new Example(1);<br></div><div>$bar =
=3D $foo;<br></div><div>$foo-&gt;inc(); // foo is copied on mutation, an=
d $foo points at the new value on return.<br></div><div>echo $bar-&gt;x;=
 // 1<br></div><div>echo $foo-&gt;x; // 2<br></div><div><br></div><div>T=
o me, this seems like it would be even more intuitive; $foo has the valu=
e you would expect from outside the class and doesn't require you keepin=
g track of the value yourself. Though, there are some footguns here too:=
<br></div><div><br></div><div>class Foo {<br></div><div>&nbsp; Example $=
bar;<br></div><div><br></div><div>&nbsp; function baz() {<br></div><div>=
&nbsp; &nbsp; $bar =3D $this-&gt;bar; // should be $bar =3D &amp;$this-&=
gt;bar<br></div><div>&nbsp; &nbsp; $bar-&gt;inc();<br></div><div>&nbsp; =
&nbsp; echo $this-&gt;bar-&gt;x; // not incremented<br></div><div>&nbsp;=
 }<br></div><div>}<br></div><div><br></div><div>I could go either way on=
 this one, honestly; so it makes sense to me why structs would have a de=
dicated syntax for whichever you prefer. On the one hand, it currently r=
equires 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.<br></div><div><br></div><div>I supp=
ose 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.</div><d=
iv><br></div><blockquote type=3D"cite" id=3D"qt" style=3D""><pre class=3D=
"qt-moz-signature" cols=3D"72">??--=20=0ARowan Tommins=0A[IMSoP]<br></pr=
e></blockquote><div><br></div><div id=3D"sig121229152">=E2=80=94 Rob<br>=
</div></body></html>
--af76a5a65d02442494fa1a85e9edd141--