[ruby-core:112359] [Ruby master Feature#10343] Postfix notations for `when` and `else` inside `case` statement

["rubyFeedback (mark potter) via ruby-core" <ruby-core@ml.ruby-lang.org>]

Issue #10343 has been updated by rubyFeedback (mark potter).


I do not necessarily have any opinion in favour, but neither
in disfavour. Kazuki's old comment probably refers primarily
to syntax-wise how the "when" do not align, so on that note 
aligned "when" would look prettier. Actually the trailing 
"else" is the most confusing part to me; the "when" does not
seem that awkward, even though it is a bit.

It may be interesting to ask matz's opinion nonetheless either
way - if he were to start ruby from scratch, would he opt for
such a syntax; after all we have had other additions such as
endless method definitions or pattern matching. :)

(I for one would love to see case/when become a more "first-class
citizen" feature, where we could query its internal state at all
times, or use different case/when to be combined, a bit like 
treating them as objects with specific state and behaviour - but
I guess I should add a new request rather than repurpose
Tsuyoshi's issue here.)





----------------------------------------
Feature #10343: Postfix notations for `when` and `else` inside `case` statement
https://bugs.ruby-lang.org/issues/10343#change-101802

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
----------------------------------------
In a `case` statement, the condition part (`when ...`) in the branches do not have the same length in general, and especially, `else` is much shorter than the conditions. So when we write the condition and the return value in a single line, they are not aligned, and are hard to read.

```ruby
case foo
  when some_very_long_proc then "a"
  when short_regex then "bbb"
  when some_long_regex then "cc"
  else "dddd"
end
```

I propose to allow postfix notations with `when` and `else` (or `otherwise`) inside `case` statement as below:

```ruby
case foo
  "a" when some_very_long_proc
  "bbb" when short_regex
  "cc" when some_long_regex
  "dddd" else
end
```

Pros are:

1) Postfix notation does not require `then` or `;`, so it is concise.

2) The return values from the branches (e.g., `"a"`, `"bb"`, `"ccc"`, `"dddd"`) tend to be shorter and more uniformly lengthened than the conditions, hence they are somewhat close to being aligned naturally, making this easier to read.

3) We are usually more interested in the return value than the condition of a branch, especially when we are reading someone's code and are trying to grasp what the `case` statement does or returns.

4) This notation is closer to case-like conditional notations regularly used in mathematics:

    ```
         ┌ 1          (x = 0)
    x! = ┤
         └ x (x - 1)! (otherwise)
    ```

    So it would be easier to read for those who are familiar with mathematics.




-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/