[ruby-core:107365] [Ruby master Feature#18368] Range#step semantics for non-Numeric ranges

Issue #18368 has been updated by zverok (Victor Shepelev).


Some clarifications after rereading the corresponding [dev.meeting log](https://github.com/ruby/dev-meeting-log/blob/master/DevMeeting-2022-01-13.md#feature-18368-rangestep-semantics-for-non-numeric-ranges-zverok):

**My proposal is not about `Time`, but about generic behavior.** 

Besides `Time`, realistic, existing, types to handle are at least:

* `Date` and `DateTime`
* and any other date-alike/time-alike objects of third-party gems, say, "time-of-day" object (gem [tod](https://github.com/jackc/tod)): 

```ruby
require 'tod'
require 'active_support/all'
(Tod::TimeOfDay.parse("8am")..Tod::TimeOfDay.parse("10am")).step(30.minutes).to_a 
#=> [#<Tod::TimeOfDay 08:00:00>, #<Tod::TimeOfDay 08:30:00>, #<Tod::TimeOfDay 09:00:00>, #<Tod::TimeOfDay 09:30:00>, #<Tod::TimeOfDay 10:00:00>]
```
* ...or `ActiveSupport::Duration` itself:

```ruby
(1.minute..20.minutes).step(2.minutes).to_a
#=> [1 minute, 3 minutes, 5 minutes, 7 minutes, 9 minutes, 11 minutes, 13 minutes, 15 minutes, 17 minutes, 19 minutes]
```

* Matematical vectors and matrices:

```ruby
require 'matrix'
(Vector[1, 2, 3]..).step(Vector[1, 1, 1]).take(3)
#=> [Vector[1, 2, 3], Vector[2, 3, 4], Vector[3, 4, 5]]
```

* Quantities with measurement units:

```ruby
require 'unitwise'
(Unitwise(0, 'km')..Unitwise(1, 'km')).step(Unitwise(100, 'm')).map(&:to_s)
#=> ["0 km", "1/10 km", "1/5 km", "3/10 km", "2/5 km", "0.5 km", "3/5 km", "7/10 km", "4/5 km", "9/10 km", "1 km"]
```

* ...any other custom type with meaningful semantic of addition

**I believe that simple and explicable semantics of reusing `+` is enough**. It creates a good quick intuition of "what would happen", which requires no exceptions and clarifications.

We already following similar approach in different places: for example, `('2.7'..'3.1') === '3.0.1'` "just works" without any additional nuances, even if `('2.7'..'3.1').to_a` wouldn't produce `3.0.1` as one of the "range contained elements".

For another close example, things like `('5'..'a').to_a` "just work", even if rarely semantically sound, because they follow a simple rule of "just uses `#succ`, however it is defined".

Finally, as stated above, **I don't think that _unexpected yet useful_ results of simple intuitions are bad**—vice versa, it is funny and enlightening that this "just works as expected":
```ruby
(''..'######').step('#').to_a
# => ["", "#", "##", "###", "####", "#####", "######"]
```

----------------------------------------
Feature #18368: Range#step semantics for non-Numeric ranges
https://bugs.ruby-lang.org/issues/18368#change-96266

* Author: zverok (Victor Shepelev)
* Status: Open
* Priority: Normal
----------------------------------------
I am sorry if the question had already been discussed, can't find the relevant topic.

"Intuitively", this looks (for me) like a meaningful statement:

```ruby
(Time.parse('2021-12-01')..Time.parse('2021-12-24')).step(1.day).to_a
#                                                         ^^^^^ or just 24*60*60
```
Unfortunately, it doesn't work with "TypeError (can't iterate from Time)".
Initially it looked like a bug for me, but after digging a bit into code/docs, I understood that `Range#step` has an odd semantics of "advance the begin N times with `#succ`, and yield the result", with N being always integer:
```ruby
('a'..'z').step(3).first(5)
# => ["a", "d", "g", "j", "m"]
```

The fact that semantic is "odd" is confirmed by the fact that for Float it is redefined to do what I "intuitively" expected:
```ruby
(1.0..7.0).step(0.3).first(5)
# => [1.0, 1.3, 1.6, 1.9, 2.2] 
```
(Like with [`Range#===` some time ago](https://bugs.ruby-lang.org/issues/14575), I believe that to be a strong proof of the wrong generic semantics, if for numbers the semantics needed to be redefined completely.)

Another thing to note is that "skip N elements" seem to be rather "generically Enumerable-related" yet it isn't defined on `Enumerable` (because nobody needs this semantics, typically!)

Hence, two questions:
* Can we redefine generic `Range#step` to new semantics (of using `begin + step` iteratively)? It is hard to imagine the amount of actual usage of the old behavior (with String?.. to what end?) in the wild
* If the answer is "no", can we define a new method with new semantics, like, IDK, `Range#over(span)`?



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

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