[RFC] Match expression

Hi,

Something like:

function match($x) {
switch(true) {
case $x === 1:
return 'Tiny';
case is_numeric($x) && $x <= 10:
return 'Small';
case is_numeric($x) && $x <= 20:
return 'Medium';
case is_numeric($x) && $x <= 30:
return 'Large';
case is_numeric($x) && ($x >= 31 || $x <= 100):
return 'Enormous';
case $x instanceof Foo:
case $x instanceof Bar:
return 'What?';
default:
return 'Unknown';
}
}

the problem is you need is_numeric because no type safe version of <=
and >= exists.

wrote in message news:eb28362c-4f8f-45df-bbf0-582e8ad2b8af@Spark...

Hi everybody!

Has this idea been discussed before?

I find myself writing switch statements in PHP quite rarely. This has a few
reasons:

1. It doesn’t have a "strict_types” version
2. It is quite verbose (lots of breaks)
3. It is a statement rather than an expression

Often, if / elseif statements turn out to be shorter, safer and easier to
read than the switch statement.
What I’d really love is something like a match expression:

If there are circumstances where a series of if / elseif statements turn out
to be shorter, safer and easier to read than a switch statement, then the
intelligent thing to do would be to use if / elseif statements instead of
trying to make the switch statement more complicated. If your problem with
the switch statement is that you sometimes forget to insert a break
statement then that is your fault. Try to use the language features as they
were intended to be used and not how you would personally like to use them.
Millions of other programmers have no problem with the switch statement, and
they would not be pleased to have it changed just to deal with your
perceived problem with it.

--
Tony Marston

Hi everybody!

Has this idea been discussed before?

I find myself writing switch statements in PHP quite rarely. This has a few reasons:

1. It doesn’t have a "strict_types” version
2. It is quite verbose (lots of breaks)
3. It is a statement rather than an expression

Often, if / elseif statements turn out to be shorter, safer and easier to read than the switch statement.

I've had the idea kicking around my head for some time of a "switch-use"
statement. I keep hoping to find the time to play around with the PHP
parser and see if I can write a proof of concept implementation, just as
an excuse to get deeper into the source, but since this has come up,
I'll outline the idea.

The general form would be "switch ( expression ) use ( op ) { ... }",
where "op" is any binary operator which gives a boolean result, and the
rest looks the same as a normal PHP switch statement.

The simplest example would be to do a strict comparison by using "===":

switch ( someFunction() ) use ( === ) {
case 42:
// ...
break;
case '42':
// ...
break;
}

Which would approximately de-sugar to:

$temp = someFunction();
switch ( true ) {
case $temp === 42:
// ...
break;
case $temp === '42':
// ...
break;
}

As you can see, the switch(true) version has to use an explicit variable
to avoid re-computing the expression, which switch does for you, and you
then have to repeat the "$temp ===", obscuring the fact that all cases
are checking the same thing. A normal switch, however, can't distinguish
42 from '42', because it uses the == comparison rules.

If this were the only useful operator, we might just call it "switch
strict" or something, but here are a couple of examples with other
operators:

// Generic exception handling function
// Also useful when accepting various incompatible implementations of
something and wrapping or converting them
switch ( $e ) use ( instanceof ) {
case FooException:
case BarException:
// ...
break;
case SomeOtherException:
// ...
break;
}

// Dividing a circle into arbitrary sectors, based on this Stack
Overflow question: https://stackoverflow.com/q/44183771/157957
// Note the ability to place "default" at the top, rather than
duplicating code in an else clause
switch ( $angle ) use ( <= ) {
case 30:
default:
return Direction::Right;
break;
case 60:
return Direction::UP_RIGHT;
break;
case 120:
return Direction::UP;
break;
case 150:
return Direction::UP_LEFT;
break;
case 210:
return Direction::LEFT;
break;
case 240:
return Direction::DOWN_LEFT;
break;
case 300:
return Direction::DOWN;
break;
case 330:
return Direction::DOWN_RIGHT;
break;
}

There are a couple of ways to expand this further, if we wanted:

• Allow operators whose result isn't strictly a boolean, such as bitwise &
• Allow any 2-parameter callable in place of an operator, to have more
  complex comparisons. With Andrea's "operator functions" suggestion,
  operators would technically just be a subset of this anyway.

The below would be quite useful, but unfortunately preg_match takes
($pattern, $subject) and this would need ($subject, $pattern), so you'd
need some extra transform:

switch ( $message ) use ( 'preg_match' ) {
case '/^Missing parameter:/':
case '/^Unexpected parameter:/':
return self::MALFORMED_REQUEST;
break;
case '/.*try again later.$/':
return self::TEMPORARY_ERROR;
break;
}

Any thoughts?

Regards,

--
Rowan Collins
[IMSoP]

I find myself writing switch statements in PHP quite rarely. This has a few reasons:

1. It doesn’t have a "strict_types” version
   ...
   I assume that some people will not be so happy about having to switch-like constructs. IMO the implicit type conversion is the biggest issue here. Maybe we could offer a solution for this one at least.

I also rarely use switch, primarily because of the lack of strict comparison.
Personally I would prefer having an option for strict comparison when using switch, similar to how in_array has an optional $strict parameter.

Would it be possible to add an optional $strict parameter to switch? E.g.

switch ($i, true) {
    case 1:
        echo 'i is 1';
        break;
    case: 1.0:
        echo 'i is 1.0';
        break;
    case '1':
        echo 'i is "1"';
        break;
    case true:
        echo 'i is true';
        break;
}

-Theodore Brown

Am 10.09.2017 um 21:16 schrieb Theodore Brown:

Would it be possible to add an optional $strict parameter to
switch? E.g.

switch ($i, true) {

I'd very much prefer a "strict switch ($i) { ... }" over a second parameter.

What do either of you think of my "switch-use" proposal, which would spell this as "switch ($i) use (===)"?

That seems more complicated and confusing than either of the other options. Normally use() is for inheriting variables in anonymous functions.

where did you see use() in the proposed SYNTAX?
hint: it's not there

it's just "strict switch" versus "switch"

On Sunday, September 10, 2017 12:45 PM Rowan Collins
rowan.collins@gmail.com wrote:

Would it be possible to add an optional $strict parameter to
switch? E.g.

switch ($i, true) {

I'd very much prefer a "strict switch ($i) { ... }" over a second
parameter.

What do either of you think of my "switch-use" proposal, which would
spell this as "switch ($i) use (===)"?

That seems more complicated and confusing than either of the other
options. Normally use() is for inheriting variables in anonymous
functions.

The choice of "use" as the keyword was largely because it's already a
reserved word, with multiple meanings in different contexts. As well as
anonymous functions, it's the keyword for importing names from other
namespaces, and for including a trait into a class. I would be perfectly
happy to hear alternative keyword or syntax suggestions.

It might not need a keyword at all, as it could just be "switch ($i ===)
{ ... }" or "switch ($i) === { ... }", although I'm not that keen on
either of those.

However, I think using "===" in some form is definitely clearer than ",
true", which could mean anything; and even "strict" could have multiple
meanings - for instance, a "strict switch" might be one where "break"
was mandatory.

Regards,

--
Rowan Collins
[IMSoP]