Let Range#step delegate to begin.step

[straight-shoota]

TLDR; This lets (1.0..5.0).step work.

Resolves #9339
Precursers: #10203, #10130

Range#step previously was based on calling #succ to get the next value in the iteration. This works for discrete types like integers which define #succ. Floating point numbers don't have a clear successor, so Float#succ doesn't exist and Range(Float64, Float64)#step wouldn't work.

This patch lets Range(B, E)#step delegate to B#step (if defined), so the behaviour can be entirely implemented by the value's type. The expected interface is that of Number#step which is also extended in this patch by an exclusive argument to handle exclusive ranges.

The implementation of Number#step is very generic based on simple algebra methods and works for non-number types as well. So a follow up would extract it for re-usability (an example would be Time as per #9327).

Note: Non-discrete types don't have an inherent step size. For stepping a Time range for example, you would need to specifiy the step size explicitly. Range#step uses 1 as default value for the step size, but if the step implementation doesn't accept integer step size, it errors at compile time. The error message doesn't point exactly to the call to Range#step, but I guess that's acceptable.

The previous #succ-based implementation is retained as an alternative if begin doesn't respond to #step. This is still used for String ranges. I'm not sure if we want to keep this alternative. It's not really necessary, Range can just expect every stepable type to implement #step. But this is a more complex discussion, because #succ and #pred methods are currently the defining interface of value types for many methods on Range.

So, for now I would just add this as an enhancement. The diff in range.cr is actually pretty minimal, it's best viewed with whitespace option.

[asterite]

Is there an existing spec for this?

[straight-shoota]

Yes, I just copied this method from Range::StepIterator because the sum specs in range_spec happen to call this method. Especially these specs runs very long without it:

crystal/spec/std/range_spec.cr

Lines 110 to 111 in cb09b0e

	(BigInt.new("1")..BigInt.new("1 000 000 000")).sum.should eq BigInt.new("500 000 000 500 000 000")
	(BigInt.new("1")..BigInt.new("1 000 000 000")).step(2).sum.should eq BigInt.new("250 000 000 000 000 000")

[asterite]

Shouldn't this return?

[straight-shoota]

Haha, yeah. That's just copied 1:1 from Range::StepIterator 😆

[asterite]

Can't wait to step through Time!

But what's the default step there?

[straight-shoota]

None. I mentioned this in the OP. Stepping through non-discrete types like Time requires a step argument.