Shorthand proposal for associative arrays View as Markdown

Maybe you should see the extract() method. It will receive strings as
varargs and will create an associative array with the string name and the
value, similar to your first example.

html::img(extract('src', 'alt'));

2018-01-26 16:16 GMT-02:00 Christian Schneider cschneid@cschneid.com:

Hi there,
I have a proposal for a shorthand notation of associative arrays borrowed
from another language:
:$foo
would be equivalent to
'foo' => $foo
and would work with array, list or []

Motivation behind it, maybe someone else finds more good uses:

1. Emulating named parameters with associative arrays like
   html::img([ 'src' => $src, 'alt' => $alt ]);
   could be written as
   html::img([ :$src, :$alt ]);
   which encourages consistent naming of variables and parameters

2. Simplifying list destructuring with non-integer keys, example taking
   from http://php.net/manual/en/migration71.new-features.php#
   migration71.new-features.support-for-keys-in-list
   foreach ($data as ["id" => $id, "name" => $name]) {
   becomes
   foreach ($data as [ :$id, :$name ]) {
   which reduces redundancy.

I implemented a minimal patch (2 lines are added to the parser) to
implement this which you can find at
https://cschneid.com/php/php7_2/assoc_array_shorthand.patch

What do you think, is this worth an RFC? I hope I didn't miss an existing
one :-)

Regards,

• Chris

--

--
David Rodrigues

Forgot something in the previous post...

On Fri, Jan 26, 2018 at 12:16 PM, Christian Schneider <cschneid@cschneid.com

wrote:

Hi there,
I have a proposal for a shorthand notation of associative arrays borrowed
from another language:
:$foo
would be equivalent to
'foo' => $foo
and would work with array, list or []

Motivation behind it, maybe someone else finds more good uses:

1. Emulating named parameters with associative arrays like
   html::img([ 'src' => $src, 'alt' => $alt ]);
   could be written as
   html::img([ :$src, :$alt ]);
   which encourages consistent naming of variables and parameters

The most similar extant feature to this is compact, but it's not as compact
as this syntax.

$src = 'my.jpg';
$alt = 'My alt';
html::img(compact($src, $alt));

will accomplish the same thing since compact does the reverse of extract -
it pulls the specified variables from the local scope and puts them into an
associative array.

Hi there,
I have a proposal for a shorthand notation of associative arrays borrowed from another language:
:$foo
would be equivalent to
'foo' => $foo
and would work with array, list or []

Motivation behind it, maybe someone else finds more good uses:

1. Emulating named parameters with associative arrays like
   html::img([ 'src' => $src, 'alt' => $alt ]);
   could be written as
   html::img([ :$src, :$alt ]);
   which encourages consistent naming of variables and parameters

2. Simplifying list destructuring with non-integer keys, example taking from http://php.net/manual/en/migration71.new-features.php#migration71.new-features.support-for-keys-in-list
   foreach ($data as ["id" => $id, "name" => $name]) {
   becomes
   foreach ($data as [ :$id, :$name ]) {
   which reduces redundancy.

I implemented a minimal patch (2 lines are added to the parser) to implement this which you can find at
https://cschneid.com/php/php7_2/assoc_array_shorthand.patch

What do you think, is this worth an RFC? I hope I didn't miss an existing one :-)

Regards,

• Chris

Hi Chris!

I really like this proposal. compact is cumbersome to use, or lets
say, almost impossible without an intelligent IDE. However, what is more
important is the fact that is would allow for a very readable and usable
approach for destructuring of associative arrays (as illustrated by your
example) which is very, very neat. The change is also extremely minimal
which speaks for it.

I would support you in writing up an RFC for this (if desired).

--
Richard "Fleshgrinder" Fussenegger

Hi!

Hi there,
I have a proposal for a shorthand notation of associative arrays borrowed from another language:
:$foo
would be equivalent to
'foo' => $foo
and would work with array, list or []

I'm always a little suspicious of features that give meaning to the name
of a variable, because I consider variable names to be an important part
of the readability of code, and the encapsulation of an implementation.
As such, I want to be able to rename local variables as part of tweaking
how a particular function is written. For instance, I'm not in favour of
introducing named parameters based on existing function signatures,
because it makes names which were previously local into part of the
function's public signature.

While this particular proposal doesn't prevent refactoring in the way
named parameters would, it adds one more thing to trip up on: when
renaming $foo to $bar, [:$foo] needs to be changed to ['foo' => $bar].

1. Emulating named parameters with associative arrays like
   html::img([ 'src' => $src, 'alt' => $alt ]);
   could be written as
   html::img([ :$src, :$alt ]);
   which encourages consistent naming of variables and parameters

This smells of bad code to me: it either means your functions are very
closely coupled, and the variables have exactly the same meaning in both
scopes; or that one or other name is poorly chosen, and doesn't reflect
its meaning in the scope where it's used.

In this example, $alt would probably have come from some other string,
which could more appropriately be labelled $productName, or $bookTitle,
or whatever the image is showing. If the values are constructed just for
this function call, I would prefer to read:

    html::img([
         'src' => $imageDomain . $coverImagePath,
         'alt' => "$bookTitle by $authorName"
    ]);

as opposed to:

   $src = $coverImagePath . $coverImagePath;
   $alt = "$bookTitle by $authorName";
   html::img([ :$src, :$alt ]);

2. Simplifying list destructuring with non-integer keys, example taking from http://php.net/manual/en/migration71.new-features.php#migration71.new-features.support-for-keys-in-list
   foreach ($data as ["id" => $id, "name" => $name]) {
   becomes
   foreach ($data as [ :$id, :$name ]) {
   which reduces redundancy.

This example feels a bit more compelling, but again it assumes that you
want the local name to match the array key, rather than having a name
appropriate to the current task. For instance, you might well be dealing
with other things which have IDs and names, and want to differentiate:

   foreach( $bookList as ["id" => $bookId, "name" => $bookName ] ) {

I'm not dead against this proposal, but it's not one I'd be using often
myself, and personally I think it would lead to more bad code than good.

Regards,

--
Rowan Collins
[IMSoP]