```Issue #16818 has been updated by sawa (Tsuyoshi Sawada).

inopinatus (Joshua GOODALL) wrote in #note-8:
>  their division seems intuitively identical to cutting a line into parts. [...] Division is therefore cutting that line into parts

That is exactly what I am saying (although I am not sure why you need to refer to complex numbers; and actually, a path is a more complex notion in complex space).

> the modulo operator the inverse i.e. the act of traversing that interval in fixed steps.

I do not understand this statement of yours. The modulo operator divides a sequence into parts as well. Regarding this point, there is no difference between the two operations. The difference is that division divides it into consecutive parts whereas the modulo operator divides it evenly in a manner as you would deal the cards in a card game.

----------------------------------------
Feature #16818: Rename `Range#%` to `Range#/`
https://bugs.ruby-lang.org/issues/16818#change-85303

* Status: Open
* Priority: Normal
----------------------------------------
`Range#%` was introduced as an alias of `Range#step` by 14697, but it is counter-intuitive and confusing.

Iteration in the following:

```ruby
((5..14) % 3).each{|i| p i}
#>> 5
#>> 8
#>> 11
#>> 14
```

is not based on `x % y` in any sense. In fact, actually applying `% 3` to the selected elements returns a unique value `2`, and it is not obvious how this is related to the iteration.

```ruby
[5, 8, 11, 14].map{|i| i % 3}
# => [2, 2, 2, 2]
```

Rather, the concept seems to be based on `/`. Applying `/ 3` to the relevant elements returns a sequence `1, 2, 3, 4`.

```ruby
[5, 8, 11, 14].map{|i| i / 3}
# => [1, 2, 3, 4]
```

Hence, `(5..14).step(3)` can be interpreted like this: Iterate over the [equivalence class](https://en.wikipedia.org/wiki/Equivalence_class) (quotient set) of range `5..14` yielded by `/ 3`.

Notice that the number of elements in `[5, 8, 11, 14]` is 4, which is `(14 - 5 + 1) / 3.0).ceil`, but is not related to `%`.

So I propose that the alias of `Range#step` should be `Range#/`, and `Range#%` should be deprecated as soon as possible before its use accumulates:

```ruby
((5..14) / 3).each{|i| p i}
#>> 5
#>> 8
#>> 11
#>> 14
```

---

P.S.

And if `Range#%` were to be introduced at all, I would rather expect it to behave like the following:

```ruby
((5..14) % 3).each{|i| p i}
#>> 5
#>> 6
#>> 7
```

which is why I claimed above that the current `Range#%` is confusing.

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