Reconstruction expression with explicit deconstuctor (REWED)

[Brian Goetz]

(cross-posting to -comments is discouraged)

If we are reconstructing something as trivial as a Point, we might not 
even use a reconstruction expression, since an ordinary constructor 
invocation is probably good enough (it only has two components, and 
we're changing at least one of them.)

Now imagine you are reconstructing something with a dozen components, 
which is where reconstruction expressions offer more value.  I don't 
think people would be very happy with a syntax like

     thingie with Thingie(var a, var b, var c, var d, var e,
                          var f, var g, var h, var i, var j) { a = 3 }



On 10/18/2023 8:01 PM, David Alayachew wrote:
> Also adding @amber-dev <mailto:amber-dev at openjdk.org>
>
> On Wed, Oct 18, 2023 at 8:00 PM David Alayachew 
> <davidalayachew at gmail.com> wrote:
>
>     Adding -comments
>
>     On Sat, Sep 23, 2023 at 10:54 AM Attila Kelemen
>     <attila.kelemen85 at gmail.com> wrote:
>
>         Note: I think you would have a better chance, if you sent the
>         email to "amber-spec-comments" than "observers", since the
>         people who can actually make changes are more likely to read
>         the "comments" list.
>
>         That said, I don't really see the usefulness of such a syntax
>         (and adding new syntax in itself is a detriment). That is, if
>         I understood you correctly, then your example would replace this:
>
>         ```
>         Point p = ...;
>         Point pp = new Point(p.x() + 2, 0);
>         ```
>
>         which is shorter and a lot more obvious. And if we were to go
>         to more complicated things (many properties), then it doesn't
>         help that much, because as far as I understand you, your
>         proposal is still positional in its deconstruction pattern,
>         and the positional nature is usually what is awkward in
>         structures with many properties.
>
>
>         Harrison Chikwe <nhcdeveloper at gmail.com> ezt írta (időpont:
>         2023. szept. 23., Szo, 12:01):
>
>             Hi,
>
>             I think that it is very useful to have when working with
>             immutable objects.
>
>             For the purposes of this mail, let's call the design
>             described in the ambro-doc[1]:
>             reconstruction expression with implicit deconstructor (aka
>             REWID).
>
>             Has it been considered to make the deconstructor pattern
>             explicit in the reconstruction
>             expression (aka REWED)?
>             Doing so may remove the requirement to make names more
>             significant in the language.
>
>             For example, given the following:
>
>             Point p = ...;
>             Point pp = p with(int x, int y) { x += 2; y = 0; }
>
>             We can interpret the reconstruction expression above as:
>
>             . Find a deconstructor and constructor pair that has a
>             signature that matches (int, int)
>             . Deconstruct the target with the deconstructor
>             . Execute the block on RHS
>             . Invoke the constructor with the result.
>
>             If we split the reconstruction expression into three steps:
>
>             1. Extraction
>             2. Transformation
>             3. Construction
>
>             In REWID users are required only to do step 2
>             (transformation) and the
>             system handles 1 and 3. Whereas in REWED users are
>             required to do step 1 and 2
>             and the system handles just step 3.
>
>             # Other forms of REWED
>
>             1. Explicit Named deconstructor pattern
>
>                Point pp = p with Point(int x, int y) {...}
>
>             2. Explicit Var deconstructor pattern
>
>                Point pp = p with var(int x, int y) {...}
>
>             3. Explicit Unnamed deconstructor pattern
>
>                Point pp = p with(int x, int y) {...}
>
>
>             We can extend form 1 to include factory pattern:
>
>                Point pp = p with Point.factory(int x, int y) {...}
>
>
>             # Advantages
>
>             1. No need to make names significant.
>             2. Can be combined with other patterns (e.g. unnamed
>             pattern, var pattern)
>
>                Point pp = p with(int x, _) { x = 0; }
>
>
>             Nyehamene.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/amber-spec-observers/attachments/20231018/851b0b79/attachment-0001.htm>