[New Concept]: Range

[meatball133]

No description provided.

[kotp]

That is about as far as I had time to go through, but please see the suggested changes, and there are some statements that I believe are not correct that should be changed as well.

[kotp]

The return is not what this statement returns, as we can see. Using IRB, since IRB "evaluated" syntax is being used here in the code example:

Suggested change

	```ruby
	1..5 # => 1, 2, 3, 4, 5
	1...5 # => 1, 2, 3, 4
	```
	In IRB:
	```ruby
	>> (1..5)
	=> 1..5
	>> (1...5)
	=> 1...5
	```

What do you think? The return is not like it would be with an Array.

Probably not in this section, but we can coerce this to an Array to show what is originally here:

>> (1..5).to_a
=> [1, 2, 3, 4, 5]
>> (1...5).to_a
=> [1, 2, 3, 4]

[kotp]

Suggested change

	Ranges can also be created using the `Range` initializer.
	```ruby
	Range.new(1, 5) # => 1, 2, 3, 4, 5
	```
	Ranges can also be created using the `Range` initializer.
	Exploring in IRB:
	```ruby
	>> Range.new(1, 5)
	=> 1..5

[kotp]

Suggested change

	That is by creating a range with the start and end index of the substring.
	That is, by creating a range with the start and end index of the sub-string.

[kotp]

Suggested change

	| Method | Description | Example |
	| ----------------------- | ----------------------------------------------------------------------- | ------------------------------- |
	| [`sum`][sum] | Returns the sum of all the values in the range | `(1..5).sum # => 15` |
	| [`size`][size] | Returns the size of the range | `(1..5).size # => 5` |
	| [`include?`][indlude] | Returns `true` if the range includes the given value, otherwise `false` | `(1..5).include?(3) # => true` |
	| Method | Description | Example |
	| ----------------------- | ----------------------------------------------------------------------- | ------------------------------- |
	| [`sum`][sum] | Returns the sum of all the values in the range | `(1..5).sum # => 15` |
	| [`size`][size] | Returns the size of the range | `(1..5).size # => 5` |
	| [`include?`][indlude] | Returns `true` if the range includes the given value, otherwise `false` | `(1..5).include?(3) # => true` |

[kotp]

I wonder if they are really special ranges, or if this is more "syntactic sugar" that lets us express the normal ranges like this.

[kotp]

irb(main):004:0> Range.new(nil, 5)
ArgumentError: bad value for range
        from (irb):4:in `initialize'
        from (irb):4:in `new'
        from (irb):4
        from :0
irb(main):005:0> (nil..5)
ArgumentError: bad value for range
        from (irb):5
        from :0
irb(main):006:0> 

I do not think this is true, demonstrably.

[meatball133]

Looking in the docs are there also mention of nil: https://rubyapi.org/3.2/o/range.

[kotp]

Thanks. That is why I said think... and did it in an REPL, to verify. Seems like it has changed for newer versions of Ruby.

So I would then expect it to no longer be a terminated by infinity anything, and perhaps "undefined" in behavior. I will definitely look at the source code. Pretty sure the use will not change from 1..infinity as 1..nil though. (That would be surprising, but nil evaluates as 0 if we do to_i and as 0.0 if we do nil.to_f so definitely worth investigating.

[kotp]

Oh, you sent a picture too. Whatever it is, I a sure it supports your statement. Not at a good device at the moment to get interpretations for pictures.

[kotp]

Just for information, I happened to have a Pry session open, where Pry has a bug that does not show this as it is supposed to. That was the reason it was broken as shown. Not the syntax itself. "Bad Pry!"

[kotp]

Suggested change

	Using beginless and endless ranges is useful when you want to for example slice a string from the beginning or to the end.
	Using beginless and endless ranges is useful when you want to, for example, slice a string from the beginning or to the end.

[kotp]

Suggested change

	If not used on a collection, the endless range can cause an infinite loop, if not used with caution.
	If not used on a collection, the endless range can cause an endless sequence, if not used with caution.

Because it does not loop, it is more an endless sequence than and endless loop.

[meatball133]

Yeah, I mean it could cause an infinte loop if you iterate over the sequence, but yes I think saying it is an endless sequence is better.

[kotp]

Suggested change

	But its behavior is a bit different than with chars, when using multiple characters in a string range.
	But its behavior is a bit different than with `chars`, when using multiple characters in a string range.

I believe you may be referring to the method, and so that should be code formatted.

[kotp]

Suggested change

	"aa".."az" # => "aa", "ab", "ac", ..., "az"
	In IRB:
	>> "aa".."az"
	=> "aa", "ab", "ac", # continues until "az"

We could use a smaller sequence as well, and still demonstrate this, so we do not have to allude to the missing content.