On Wed, Jun 26, 2024, at 23:42, Ilija Tovilo wrote:
>
> function test($value) {
> if ($value is ['foo' => ?string]) {
> $foo = $value['foo'];
> }
> }
> test([]);
(Scroll to the end if you don’t care about my rebuttal)
I mean, there’s nothing wrong with this code, $foo will be null at the end.
>
> With your approach, the example above would emit a warning, even
> though the context within test() doesn't look like it should.
That happens every time I get one of these warnings. It’s nice to get the heads
up that I didn’t think through something and need to either A) figure out how
it got there, or B) provide a default — even if it is null — to make the
warning go away.
> If ?string means that the index might or might not exist, all code that
> accesses them must check for existence, even when not needing to
> handle null itself. That doesn't seem desirable to me.
This is true already. since this warning and null-coalescence, I can probably
count on one hand the number of times I’ve *not* written something like ?? null
beside an array access (though I prefer throwing an exception if appropriate).
>
> I also think the issue goes further. If anything|null means that the
> offset might not exist, does that include mixed? That makes ['foo' =>
> mixed] essentially useless.
In thinking about it some more, for lists, it would be nice if there were two
modes:
1. regular mode: $a is [1,2,3] where it must match exactly.
2. set mode: $a is set([1,2,3]) where order doesn’t matter, only that $a
contains at least one of every given element.
——————
In other news, I finally found a realistic example where there is a difference
between non-existence and null.
The scenario is this:
Imagine you accept a callback and you prepare an array to pass as parameters.
In this case, you call the callback like so:
$callback(…$args);
Today, you either have to yolo it and hope everything is perfect or
meticulously check the args to make sure the types match your documented
callback signature.
If a key in $args doesn’t exist, it might be an error (or default value
provided by the callback implementation) but if it is null, it might also be
disastrously incorrect because the default value won’t be used.
By using pattern matching, we can check the structure of the array for
non-existence or if exists, the documented type. This is where matching a list
exactly is important (if using positional args).
So, now that there is a use case for it, we can work out expected behaviors of
lists and associative arrays and nullability for both.
Anyway, does anyone have a suggestion for what kind of hat I should have for
dinner?
— Rob
