struct Range(B, E)
inherits Struct
¶
A Range represents an interval: a set of values with a beginning and an end.
Ranges may be constructed using the usual new method or with literals:
x..y # an inclusive range, in mathematics: [x, y]
x...y # an exclusive range, in mathematics: [x, y)
(x..) # an endless range, in mathematics: >= x
..y # a beginless inclusive range, in mathematics: <= y
...y # a beginless exclusive range, in mathematics: < y
An easy way to remember which one is inclusive and which one is exclusive it to think of the extra dot as if it pushes y further away, thus leaving it outside of the range.
Ranges typically involve integers, but can be created using arbitrary objects
as long as they define succ (or pred for reverse_each), to get the
next element in the range, and < and ==, to know when the range reached the end:
# Represents a string of 'x's.
struct Xs
include Comparable(Xs)
getter size
def initialize(@size : Int32)
end
def succ
Xs.new(@size + 1)
end
def <=>(other)
@size <=> other.size
end
def inspect(io)
@size.times { io << 'x' }
end
def to_s(io)
io << @size << ' '
inspect(io)
end
end
An example of using Xs to construct a range:
r = Xs.new(3)..Xs.new(6)
r.to_s # => "xxx..xxxxxx"
r.to_a # => [Xs.new(3), Xs.new(4), Xs.new(5), Xs.new(6)]
r.includes?(Xs.new(5)) # => true
Included modules
Enumerable
Iterable
Class methods¶
.new(begin __arg0 : B, end __arg1 : E, exclusive : Bool = false)
¶
(begin __arg0 : B, end __arg1 : E, exclusive : Bool = false)
Constructs a Range using the given beginning and end.
Range.new(1, 10) # => 1..10
Range.new(1, 10, exclusive: true) # => 1...10
Methods¶
#===(value)
¶
(value)
Same as includes?, useful for the case expression.
case 79
when 1..50 then puts "low"
when 51..75 then puts "medium"
when 76..100 then puts "high"
end
Produces:
high
See also: Object#===.
#begin : B
¶
: B
Returns the object that defines the beginning of this range.
(1..10).begin # => 1
(1...10).begin # => 1
#bsearch(&block : B | E -> Bool)
¶
(&block : B | E -> Bool)
By using binary search, returns the first value
for which the passed block returns true.
If the block returns false, the finding value exists
behind. If the block returns true, the finding value
is itself or exists in front.
(0..10).bsearch { |x| x >= 5 } # => 5
(0..Float64::INFINITY).bsearch { |x| x ** 4 >= 256 } # => 4
Returns nil if the block didn't return true for any value.
#cycle
¶
Returns an Iterator that cycles over the values of this range.
(1..3).cycle.first(5).to_a # => [1, 2, 3, 1, 2]
#each(&) : Nil
¶
(&) : Nil
Iterates over the elements of this range, passing each in turn to the block.
(10..15).each { |n| print n, ' ' }
# prints: 10 11 12 13 14 15
#each
¶
Returns an Iterator over the elements of this range.
(1..3).each.skip(1).to_a # => [2, 3]
#end : E
¶
: E
Returns the object that defines the end of the range.
(1..10).end # => 10
(1...10).end # => 10
#excludes_end?
¶
Returns true if this range excludes the end element.
(1..10).excludes_end? # => false
(1...10).excludes_end? # => true
#exclusive? : Bool
¶
: Bool
Returns true if the range is exclusive.
Returns false otherwise (default).
#includes?(value)
¶
(value)
Returns true if this range includes the given value.
(1..10).includes?(4) # => true
(1..10).includes?(10) # => true
(1..10).includes?(11) # => false
(1...10).includes?(9) # => true
(1...10).includes?(10) # => false
#reverse_each(&) : Nil
¶
(&) : Nil
Iterates over the elements of this range in reverse order, passing each in turn to the block.
(10...15).reverse_each { |n| print n, ' ' }
# prints: 14 13 12 11 10
#reverse_each
¶
Returns a reverse Iterator over the elements of this range.
(1..3).reverse_each.skip(1).to_a # => [2, 1]
#sample(random = Random::DEFAULT)
¶
(random = Random::DEFAULT)
Optimized version of Enumerable#sample that runs in O(1) time when self
is an Int or Float range. In these cases, this range is considered to be
a distribution of numeric values rather than a collection of elements, and
the method simply calls random.rand(self).
Raises ArgumentError if self is an open range.
#step(by = 1) : Iterator
¶
(by = 1) : Iterator
Iterates from begin to end incrementing by the amount of step on each
iteration.
ary = [] of Int32
(1..4).step(by: 2) do |x|
ary << x
end
ary # => [1, 3]
(1..4).step(by: 2).to_a # => [1, 3]
(1..4).step(by: 1).to_a # => [1, 2, 3, 4]
(1...4).step(by: 1).to_a # => [1, 2, 3]
If B is a Steppable, implementation is delegated to Steppable#step.
Otherwise #succ method is expected to be defined on begin and its
successors and iteration is based on calling #succ sequentially
(step times per iteration).
Raises ArgumentError if begin is nil.
#step(by = 1, &) : Nil
¶
(by = 1, &) : Nil
Iterates from begin to end incrementing by the amount of step on each
iteration.
ary = [] of Int32
(1..4).step(by: 2) do |x|
ary << x
end
ary # => [1, 3]
(1..4).step(by: 2).to_a # => [1, 3]
(1..4).step(by: 1).to_a # => [1, 2, 3, 4]
(1...4).step(by: 1).to_a # => [1, 2, 3]
If B is a Steppable, implementation is delegated to Steppable#step.
Otherwise #succ method is expected to be defined on begin and its
successors and iteration is based on calling #succ sequentially
(step times per iteration).
Raises ArgumentError if begin is nil.
#sum(initial)
¶
(initial)
Optimized version of Enumerable#sum that runs in O(1) time when self is
an Int range.