Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:109413
To: internals@lists.php.net
References: <CAJmjfvW8b=jYTjLfW9N9FT_eQVS7RBe768NZXv-g4V2RM3OgtA@mail.gmail.com>
 <CAJmjfvUcONYKvRKvAXB8x5n3faRwxntbg5q25Nan2aZrSNznXQ@mail.gmail.com>
Message-ID: <ab89d411-c699-b80b-4cfe-7338cdae6c42@gmail.com>
Date: Sun, 29 Mar 2020 16:00:25 +0100
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:68.0) Gecko/20100101
 Thunderbird/68.6.0
MIME-Version: 1.0
In-Reply-To: <CAJmjfvUcONYKvRKvAXB8x5n3faRwxntbg5q25Nan2aZrSNznXQ@mail.gmail.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Content-Language: en-GB
Subject: Re: [PHP-DEV] [RFC] [DISCUSSION] Compact Object Property Assignment
From: rowan.collins@gmail.com (Rowan Tommins)

On 28/03/2020 21:37, Jakob Givoni wrote:
> I really believe that COPA can help thousands of PHP developers
> without introducing any new complexities to the language and my hope
> is that perfect won't be the enemy of good this time around :-)
>
> Any last words unsaid before the final lap commences?


Hi Jakob,

It occurred to me thinking about alternative syntaxes that COPA could be 
seen as a limited form of the "with" statement found in some languages, 
e.g. JS [1], VisualBasic [2], Delphi [3], Groovy [4] (note that with 
blocks in Python are something different).

[1] 
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with
[2] 
https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/statements/with-end-with-statement
[3] http://www.delphibasics.co.uk/RTL.asp?Name=With
[4] 
https://docs.groovy-lang.org/latest/html/groovy-jdk/java/lang/Object.html#with(boolean,%20groovy.lang.Closure)


The Groovy version is particularly relevant, since it can be used as an 
expression, not just a statement block, so this example from your RFC:

doTheFoo((new Foo)->[
     a = 1,
     b = 2,
     c = 3,
]);

would I think look something like this in Groovy:

doTheFoo(new Foo().with(true) {
     a = 1
     b = 2
     c = 3
})


The notable differences between COPA and with blocks are:

- with statements generally allow methods as well as properties to be 
referenced on the given object
- with blocks contain a series of full statements in some form (either a 
syntactical block, or some form of closure); COPA instead contains a 
special list of key-value pairs
- with blocks generally fall back to other scopes if a property or 
method is not found, and are often criticised for the resulting ambiguity


COPA trades the scope ambiguity for reduced flexibility: the left-hand 
side of each assignment is always a property name, and the 
right-hand-side is a normal expression, so doesn't benefit from the syntax.

This example from the RFC:

$myObj->[
     foo = 10,
     bar = $myObj->foo + 20,
];

Wouldn't need the extra reference to $myObj in Groovy:

myObj.with {
     foo = 10
     bar = foo + 20
}

Similarly, the nesting example in Future Scope:

$foo->[
     a = 1,
     b = $foo->b->[
         c = 2,
     ],
];

Could be written something like this:

foo.with {
     a = 1
     b = b.tap {
         c = 2
     }
}


If we used a different sigil instead of $ for "property and method of 
with'd object", we could avoid the ambiguity of most with blocks, but 
get most of the power; something like this:

$foo = new Foo with {
     ->a = 1;
     ->b = ->1 + 10;
      ->c = new Bar with {
            ->d = 'Hello';
      };
     ->start();
}

I'm not sure whether I like this idea or not, but I thought I'd share 
it, because I think COPA as currently proposed is too narrow a use case 
to deserve a special syntax.


Regards,

-- 
Rowan Tommins (né Collins)
[IMSoP]