[ruby-core:100648] [Ruby master Feature#16670] Reverse order of `expression` in `pattern` for 1-line pattern matching while it's still experimental

Issue #16670 has been updated by ttilberg (Tim Tilberg).


There were notes in the recent dev meeting that affect this issue: https://github.com/ruby/dev-meeting-log/blob/master/DevelopersMeeting20201026Japan.md#feature-17260-promote-pattern-matching-to-official-feature-ktsj

`=>` is a new feature to support right hand assignment to allow things like `do_stuff.then{|things| make_things things } => hotdogs`.

1-line pattern matching is currently `"expression" in pattern`. Being very similar to right-hand assignment, it seems that `=>` will now act as 1-line pattern matching, removing `expr in pattern`. I find this attractive, as it reduces the number of concepts being added, and makes the 1-line matching more intuitive. It removes the interpretation of the word `in`, and shares the existing notions of rescue HotDogError => e and {this => that}.

Given this new direction, this issue can be closed.

Discussion:
- https://github.com/ruby/dev-meeting-log/blob/master/DevelopersMeeting20201026Japan.md#feature-17260-promote-pattern-matching-to-official-feature-ktsj
- https://bugs.ruby-lang.org/issues/17260


----------------------------------------
Feature #16670: Reverse order of `expression` in `pattern` for 1-line pattern matching while it's still experimental
https://bugs.ruby-lang.org/issues/16670#change-88286

* Author: ttilberg (Tim Tilberg)
* Status: Open
* Priority: Normal
----------------------------------------
Currently the 1-line syntax for pattern matching is:

```
# Usage: <expression> in <pattern>

expression = {
  pattern: "Example"
}

expression in {pattern: something}
# something => "Example"
```

Is it technically possible, and desirable to switch the order of this syntax to:

```
# Usage: <pattern> in <expression>

expression = {
  pattern: "Example"
}

{pattern: something} in expression
# something => "Example"

```
?

Here are my reasons:

- It is more intuitive in English -- we are "finding a pattern in something". Finding "something in a pattern" doesn't seem to make sense.
- Assignment is happening, and this keeps assignment on the left side of the operator which feels more natural.
- It matches existing behavior with the workings of the case statement:

Understanding that a `case` block evaluates each `when` expression using `when_expression === case_expression` makes more consistency with `when_pattern in case_pattern` using the new operator.

```
case something
when /pattern/
end

# is equivalent to

/pattern/ === something

# This creates more parity with

case something
in {pattern: x}

# would be equivalent to

{pattern: x} in something
```


Please see the following discussion on Reddit: https://www.reddit.com/r/ruby/comments/favshb/27s_pattern_matching_official_docs_recently_merged/fj2c7ng/



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>