Issue #16812 has been updated by nobu (Nobuyoshi Nakada).


A few bugs.

* `Float` `ArithmeticSequence` crashes.

    ```shell
    $ ./ruby -e '[*0..10][(0.0..)%10]'
    Assertion Failed: ../src/include/ruby/3/arithmetic/long.h:136:ruby3_fix2long_by_shift:"RB_FIXNUM_P(x)"
    ```

* If overridden `take_while` (and `drop_while`) returns non-`Array`, crashes.

    ```shell
    $ ./ruby 'a = (1..10)%2; def a.take_while; nil; end; [*1..10][a]'
    -e:1:in `<main>': wrong argument type nil (expected Array) (TypeError)
    ```

These resulted in assertion failures, but would segfault when compiled with `NDEBUG`.


----------------------------------------
Feature #16812: Allow slicing arrays with ArithmeticSequence
https://bugs.ruby-lang.org/issues/16812#change-85271

* Author: zverok (Victor Shepelev)
* Status: Open
* Priority: Normal
----------------------------------------
I believe when concepts of ArithmeticSequence and `Range#%` were introduced, one of the main intended usages was array slicing in scientific data processing. So, it seems to make sense to allow this in `Array#[]`:

```ruby
ary[(5..20) % 2] # each second element between 5 and 20
ary[(0..) % 3] # each third element
ary[10.step(by: -1)] # elements 10, 9, 8, 7 ....
```

PR is [here](https://github.com/ruby/ruby/pull/3055).

My reasoning is as follows:
1. As stated above, ArithmeticSequence and `Range#%` seem to have been introduced exactly for this goal
2. Python has its slicing syntax as `begin:end:step` (with a possibility to omit either), and it seems to be well respected and used feature for data processing. So I believe it is useful, and relatively easy to integrate into existing functionality

I expect the usual "it is ugly and unreadable!" backlash. 
I don't have an incentive, nor energy, to "defend" the proposal, so I would not.



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