Issue #14724 has been updated by graywolf (Gray Wolf).


After reading comments above I believe even more strongly that feature like this does not belong in language which allows you to redefine operators. It's one thing with python's `__lt__` but when we can actually redefine `<` itself to return whatever this will become too confusing for anyone trying to do so. That small saving in number of characters written does not justify the added complexity.

If it is actually implemented (I don't think it should), I think that:

1. evaluating `a < b < c` to `(a < b) && (b < c)` is incorrect since the double access to `b` is not really obvious. It would create non-obvious performance issues / bugs in both `a.get_from_db_takes_a_long_time() < b.get_from_db_takes_a_long_time() < c.get_from_db_takes_a_long_time()` and `a.get_and_increase() < b.get_and_increase() < c.get_and_increase()`. It would be better to touch each term just once.
2. It really should not be limited to "chains of inequalities", it should be implemented for all operators. Just changing `a < b < c` to `a < b == c` should not break things (again, it's not really obvious that it will stop working).

After all, if we are copying this python feature, why not copy it whole.

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

* 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>