Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:112660
MIME-Version: 1.0
In-Reply-To: <459d7ff7-e553-dce9-7d43-c3b1e772e572@gmail.com>
References: <1d0abb04-4987-43a9-85bc-bccc3bd6be9a@www.fastmail.com>
 <03108284-740a-4a5d-130f-15b2e67e9df9@mabe.berlin> <CAJpLVh2M3iKhG8b2qZydf_70K4NYdZ5fpSEsRNK7uLeESUPHKg@mail.gmail.com>
 <459d7ff7-e553-dce9-7d43-c3b1e772e572@gmail.com>
Date: Wed, 30 Dec 2020 13:49:31 +0000
Message-ID: <CAJpLVh31UzSJvKdypQ=Mh+6CLvfUCrF==z6HBDD1_nuYqFzG5A@mail.gmail.com>
To: Rowan Tommins <rowan.collins@gmail.com>
Cc: internals@lists.php.net
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Subject: Re: [PHP-DEV] Analysis of property visibility, immutability, and
 cloning proposals
From: olleharstedt@gmail.com (=?UTF-8?Q?Olle_H=C3=A4rstedt?=)

2020-12-29 21:36 GMT, Rowan Tommins <rowan.collins@gmail.com>:
> On 29/12/2020 10:28, Olle H=C3=A4rstedt wrote:
>> I just want to mention that immutability might be applied too
>> liberally in the current discourse, and in some cases, what you really
>> want is*non-aliasing*, that is, uniqueness, to solve problems related
>> to immutability. I think methods like `withX` is an anti-pattern, in
>> fact, and a symptom that you do not*really*  want immutability, but
>> rather uniqueness, at least in some cases.
>
>
> Hi Olle,
>
> I'm afraid I don't follow what you mean by "non-aliasing" and
> "uniqueness" here. Could you clarify, perhaps with some examples?
>
> Cheers,
>
> --
> Rowan Tommins
> [IMSoP]
>

Wikipedia has an article about aliasing:
https://en.wikipedia.org/wiki/Aliasing_(computing)
Also relevant: https://en.wikipedia.org/wiki/Uniqueness_type

Uniqueness is when you only allow _one_ reference to an object (or
bucket of memory).

$a =3D new A();
$b =3D $a;  // Both $a and $b point to the same place in memory, so you
have an alias

Uniqueness and immutability solves similar problems (at least in a GC
language like PHP): Spooky action at a distance, fragile composition,
rep exposure.

The are more advanced systems of ownership than just uniqueness, e.g.
Universe Types, but let's ignore that for now.
https://www.researchgate.net/publication/221321963_Ownership_transfer_in_Un=
iverse_Types

Uniqueness has the benefit of being more performant than immutability,
since it leads to less memory copy (but of course it's not certain
this performance gain matters in PHP programs).

You can compare a builder pattern with immutability vs non-aliasing
(uniqueness):

```
// Immutable
$b =3D new Builder();
$b =3D $b->withFoo()->withBar()->withBaz();
myfun($b);  // $b is immutable, so $b cannot be modified by myfun()
return $b;
```

```
// Uniqueness
$b =3D new Builder();  // class Builder is annotated as non-aliasing/unique
$b->addFoo();
$b->addBar();
$b->addBaz();
myfun(clone $b);  // HAVE TO CLONE TO NOT THROW EXCEPTION.
return $b;
```

The guarantee in both above snippets is that myfun() DOES NOT modify
$b before returning it. BUT with immutability, you have to copy $b
three times, with uniqueness only one. That's why I think ownership
system merits some attention, not ONLY immutability. :) Unfortunately,
it can take a looong time to force new concepts like these into common
discourse. Rust helps, obviously. The language Clean has opt-in
uniqueness (I need to read up more on it, tho). Linear types in e.g.
Haskell is also related (but is both more complex and more powerful).

I would like to add an annotation to Psalm, like @psalm-no-alias,
because this is also needed to make type-state sane. But, didn't do
much yet, only some brain farting. :)

Olle