Issue #14724 has been updated by phluid61 (Matthew Kerwin).


shan (Shannon Skipper) wrote:
> 
> How does this patch make things harder for experienced programmers? Reading the new syntax that others have written? I don't see that as much of a hurdle (TIMTOWTDI), but is that what you mean about making it harder?
>

Yes, a fair chunk of my professional life is taken up with reading, analysing, debugging, and refactoring others' code.  The more weird ways people have of doing things, the harder it can be to understand what they're doing, or what they *intended* to do.

>
> Or are you concerned about breaking existing code? If the latter, have any examples?
> 

No, not breaking existing code; but removing a syntax error introduces the chance of certain types of mistakes being missed.  Mangle a merge, or bump backspace, and what would have been a syntax error becomes unexpected behaviour somewhere else down the line.

For example: `x1 <= x2 && y1 < y2` vs `x1 <= x2 & y1 < y1`

>
> If this patch is merged, I'd expect many experienced Rubyists to eventually adopt this syntax with chained comparison for the sake of readable code.
>

I'm on the fence about "readbility" here.  Brevity doesn't always lead to readability (see: lambda arrow syntax ).  One of the projects I maintain is a large Perl codebase, so I have a Pavlovian negative reaction to suggestions for "brevity" or magical symbology.  Maybe if I'd come from Python I wouldn't feel so bad about it.

If I wasn't on my phone earlier I would have probably written "-", because I actually do like the fact that the middle terms are only evaluated once.

----------------------------------------
Feature #14724: chains of inequalities
https://bugs.ruby-lang.org/issues/14724#change-71775

* Author: gotoken (Kentaro Goto)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: 
----------------------------------------
In mathematics, chain of inequations is a shorthand notation for the conjunction of several inequations involving common expressions. 

For example, `a < b <= c` for `a < b && b <= c`

Chain notation makes code clearer, in particular, long common expression cases will be so. E.g., 

```
cur.to_i - 2 <= timeval.tv_sec <= cur.to_i
```

is easier to read than

```
cur.to_i - 2 <= timeval.tv_sec && timeval.tv_sec <= cur.to_i
```

because in the latter case we have to verify whether `timeval.tv_sec` is common or not by eyes.

Current syntax allows but redefining builtin methods are considered not practical. So here I request as a new syntax for the chains.


### Use cases (applicable conjunctions)

lib/matrix.rb:
```ruby
    unless 0 <= column && column < column_count
```

lib/time.rb documents:
```ruby
    # block.  For example:
    #
    #     Time.parse(...) {|y| 0 <= y && y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}
```

spec/ruby/optional/capi/bignum_spec.rb:
```ruby
  raise "Bignum#coerce returned Fixnum" if fixnum_min <= n && n <= fixnum_max
```

test/fiddle/test_import.rb:
```ruby
        assert(cur.to_i - 2 <= timeval.tv_sec && timeval.tv_sec <= cur.to_i)
```

tool/jisx0208.rb:
```ruby
        unless 0x8140 <= sjis && sjis <= 0xFCFC
```




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

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