Issue #12133 has been updated by arimay (yasuhiro arima).



Definition of a range object that exclude a start position, and its shorthand notation.

Since we have #exclude_end? we also want #exclude_begin? .

    class Range
      def initialize(begin, end, exclude_end=false, exclude_begin=false)
      def exclude_begin?

Shorthand, by known as the neko operator.

    notation        meaning         new
    b..e            b <= v <= e     Range.new(b, e)
    b..^e           b <= v <  e     Range.new(b, e, true) # the same as "b...e"
    b^..e           b <  v <= e     Range.new(b, e, false, true)
    b^..^e          b <  v <  e     Range.new(b, e, true,  true)

    with nil.

    ..e                  v <= e     Range.new(nil, e)
    ^..e                 v <= e     Range.new(nil, e)
    ..^e                 v <  e     Range.new(nil, e, true)
    ^..^e                v <  e     Range.new(nil, e, true)
    b..             b <= v          Range.new(b, nil, false, false)
    b..^            b <= v          Range.new(b, nil, false, false)
    b^..            b <  v          Range.new(b, nil, false, true)
    b^..^           b <  v          Range.new(b, nil, false, true)

The priority of the range operators is the same.

    < Higher >
    ||
    ..  ...  ..^  ^..  ^..^
    ?:
    < Lower >

Situation: Notation.

    range  =  0^..100     # 0    < v <=  100
    range  =  100^..1000  # 100  < v <= 1000
    range  =  1000^..     # 1000 < v

Situation: Pass to argument for method call.

    [ 0^..100,  100^..1000,  1000^.. ].each do |range|
      pp  Items.where( price: range ).all
    end

Situation: Build expression.(e.g. query script)

    def build( v, range )
      b  =  range.begin
      e  =  range.end
      exprs  =  []
      if range.exclude_begin?
        exprs  <<  "#{b} < #{v}"
      elsif b
        exprs  <<  "#{b} <= #{v}"
      end
      if range.exclude_end?
        exprs  <<  "#{v} < #{e}"
      elsif e
        exprs  <<  "#{v} <= #{e}"
      end
      exprs.join(" and ")
    end

The new feature will enables more clear code.
We believe this feature will be very useful for developers.



----------------------------------------
Feature #12133: Ability to exclude start when defining a range
https://bugs.ruby-lang.org/issues/12133#change-91351

* Author: slash_nick (Ryan Hosford)
* Status: Feedback
* Priority: Normal
----------------------------------------
An intuitive, approach would be to allow defining ranges like so:

~~~
[1..10]
[1..10)
(1..10]
(1..10)
~~~

... where a square bracket indicates boundary inclusion and a parenthesis represents boundary exclusion. The syntax there is obviously not going to work, but it demonstrates the idea.

A more feasible, still intuitive, solution might look like the following

~~~
(1..10)                # [1..10]
(1...10)               # [1..10) ... Alternatively: (1..10).exclude_end
(1..10).exclude_start  # (1..10]
(1...10).exclude_start # (1..10) ... Alternatively: (1..10).exclude_start.exclude_end
~~~

For consistency, I think we'd also want to add `#exclude_start?` & `#exclude_end` methods.



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