Class: Range

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain: self, `::Enumerable`
Inherits:	Object
Defined in:	range.c

Overview

A Range represents an interval—a set of values with a beginning and an end. Ranges may be constructed using the s..e and s...e literals, or with .new. Ranges constructed using .. run from the beginning to the end inclusively. Those created using ... exclude the end value. When used as an iterator, ranges return each value in the sequence.

(-1..-5).to_a      #=> []
(-5..-1).to_a      #=> [-5, -4, -3, -2, -1]
('a'..'e').to_a    #=> ["a", "b", "c", "d", "e"]
('a'...'e').to_a   #=> ["a", "b", "c", "d"]

Beginless/Endless Ranges

A “beginless range” and “endless range” represents a semi-infinite range. Literal notation for a beginless range is:

(..1)
# or
(...1)

Literal notation for an endless range is:

(1..)
# or similarly
(1...)

Which is equivalent to

(1..nil)  # or similarly (1...nil)
Range.new(1, nil) # or Range.new(1, nil, true)

Beginless/endless ranges are useful, for example, for idiomatic slicing of arrays:

[1, 2, 3, 4, 5][...2]   # => [1, 2]
[1, 2, 3, 4, 5][2...]   # => [3, 4, 5]

Some implementation details:

#begin of beginless range and #end of endless range are nil;
#each of beginless range raises an exception;
#each of endless range enumerates infinite sequence (may be useful in combination with Enumerable#take_while or similar methods);
(1..) and (1...) are not equal, although technically representing the same sequence.

Custom Objects in Ranges

Ranges can be constructed using any objects that can be compared using the <=> operator. Methods that treat the range as a sequence (#each and methods inherited from ::Enumerable) expect the begin object to implement a succ method to return the next object in sequence. The #step and #include? methods require the begin object to implement succ or to be numeric.

In the Xs class below both <=> and succ are implemented so Xs can be used to construct ranges. Note that the ::Comparable module is included so the #== method is defined in terms of <=>.

class Xs                # represent a string of 'x's
  include Comparable
  attr :length
  def initialize(n)
    @length = n
  end
  def succ
    Xs.new(@length + 1)
  end
  def <=>(other)
    @length <=> other.length
  end
  def to_s
    sprintf "%2d #{inspect}", @length
  end
  def inspect
    'x' * @length
  end
end

An example of using Xs to construct a range:

r = Xs.new(3)..Xs.new(6)   #=> xxx..xxxxxx
r.to_a                     #=> [xxx, xxxx, xxxxx, xxxxxx]
r.member?(Xs.new(5))       #=> true

Class Method Summary

.new(begin, end, exclude_end=false) ⇒ Range constructor

Constructs a range using the given #begin and #end.

Instance Attribute Summary

#exclude_end? ⇒ Boolean readonly

Returns true if the range excludes its end value.

Instance Method Summary

#%(n) ⇒ Enumerator

Iterates over the range, passing each nth element to the block.
#==(obj) ⇒ Boolean

Returns true only if obj is a Range, has equivalent begin and end items (by comparing them with ==), and has the same #exclude_end? setting as the range.
#===(obj) ⇒ Boolean

Returns true if obj is between begin and end of range, false otherwise (same as #cover?).
#begin ⇒ Object

Returns the object that defines the beginning of the range.
#bsearch {|obj| ... } ⇒ value

By using binary search, finds a value in range which meets the given condition in O(log n) where n is the size of the range.
#count ⇒ Integer

Identical to Enumerable#count, except it returns Infinity for endless ranges.
#cover?(obj) ⇒ Boolean

Returns true if obj is between the begin and end of the range.
#each {|i| ... } ⇒ Range

Iterates over the elements of range, passing each in turn to the block.
#end ⇒ Object

Returns the object that defines the end of the range.
#entries ⇒ Array

Alias for #to_a.
#eql?(obj) ⇒ Boolean

Returns true only if obj is a Range, has equivalent begin and end items (by comparing them with eql?), and has the same #exclude_end? setting as the range.
#first ⇒ Object

Returns the first object in the range, or an array of the first n elements.
#hash ⇒ Integer

Compute a hash-code for this range.
#include?(obj) ⇒ Boolean

Alias for #member?.
#inspect ⇒ String

Convert this range object to a printable form (using #inspect to convert the begin and end objects).
#last ⇒ Object

Returns the last object in the range, or an array of the last n elements.
#max ⇒ Object

Returns the maximum value in the range.
#member?(obj) ⇒ Boolean (also: #include?)

Returns true if obj is an element of the range, false otherwise.
#min ⇒ Object

Returns the minimum value in the range.
#minmax ⇒ Array, Object

Returns a two element array which contains the minimum and the maximum value in the range.
#size ⇒ Numeric

Returns the number of elements in the range.
#step(n = 1) {|obj| ... } ⇒ Range

Iterates over the range, passing each nth element to the block.
#to_a ⇒ Array (also: #entries)

Returns an array containing the items in the range.
#to_s ⇒ String

Convert this range object to a printable form (using #to_s to convert the begin and end objects).
#initialize_copy(orig) Internal use only

`::Enumerable` - Included

#all?	Passes each element of the collection to the given block.
#any?	Passes each element of the collection to the given block.
#chain	Returns an enumerator object generated from this enumerator and given enumerables.
#chunk	Enumerates over the items, chunking them together based on the return value of the block.
#chunk_while	Creates an enumerator for each chunked elements.
#collect	Alias for Enumerable#map.
#collect_concat	Alias for Enumerable#flat_map.
#count	Returns the number of items in `enum` through enumeration.
#cycle	Calls block for each element of enum repeatedly n times or forever if none or `nil` is given.
#detect	Alias for Enumerable#find.
#drop	Drops first n elements from enum, and returns rest elements in an array.
#drop_while	Drops elements up to, but not including, the first element for which the block returns `nil` or `false` and returns an array containing the remaining elements.
#each_cons	Iterates the given block for each array of consecutive <n> elements.
#each_entry	Calls block once for each element in `self`, passing that element as a parameter, converting multiple values from yield to an array.
#each_slice	Iterates the given block for each slice of <n> elements.
#each_with_index	Calls block with two arguments, the item and its index, for each item in enum.
#each_with_object	Iterates the given block for each element with an arbitrary object given, and returns the initially given object.
#entries	Alias for Enumerable#to_a.
#filter	Returns an array containing all elements of `enum` for which the given `block` returns a true value.
#filter_map	Returns a new array containing the truthy results (everything except `false` or `nil`) of running the `block` for every element in `enum`.
#find	Passes each entry in enum to block.
#find_all	Alias for Enumerable#filter.
#find_index	Compares each entry in enum with value or passes to block.
#first	Returns the first element, or the first `n` elements, of the enumerable.
#flat_map	Returns a new array with the concatenated results of running block once for every element in enum.
#grep	Returns an array of every element in enum for which `Pattern === element`.
#grep_v	Inverted version of Enumerable#grep.
#group_by	Groups the collection by result of the block.
#include?	Alias for Enumerable#member?.
#inject	Combines all elements of enum by applying a binary operation, specified by a block or a symbol that names a method or operator.
#lazy	Returns an `::Enumerator::Lazy`, which redefines most `::Enumerable` methods to postpone enumeration and enumerate values only on an as-needed basis.
#map	Returns a new array with the results of running block once for every element in enum.
#max	Returns the object in enum with the maximum value.
#max_by	Returns the object in enum that gives the maximum value from the given block.
#member?	Returns `true` if any member of enum equals obj.
#min	Returns the object in enum with the minimum value.
#min_by	Returns the object in enum that gives the minimum value from the given block.
#minmax	Returns a two element array which contains the minimum and the maximum value in the enumerable.
#minmax_by	Returns a two element array containing the objects in enum that correspond to the minimum and maximum values respectively from the given block.
#none?	Passes each element of the collection to the given block.
#one?	Passes each element of the collection to the given block.
#partition	Returns two arrays, the first containing the elements of enum for which the block evaluates to true, the second containing the rest.
#reduce	Alias for Enumerable#inject.
#reject	Returns an array for all elements of `enum` for which the given `block` returns `false`.
#reverse_each	Builds a temporary array and traverses that array in reverse order.
#select	Alias for Enumerable#filter.
#slice_after	Creates an enumerator for each chunked elements.
#slice_before	Creates an enumerator for each chunked elements.
#slice_when	Creates an enumerator for each chunked elements.
#sort	Returns an array containing the items in enum sorted.
#sort_by	Sorts enum using a set of keys generated by mapping the values in enum through the given block.
#sum	Returns the sum of elements in an `::Enumerable`.
#take	Returns first n elements from enum.
#take_while	Passes elements to the block until the block returns `nil` or `false`, then stops iterating and returns an array of all prior elements.
#tally	Tallies the collection, i.e., counts the occurrences of each element.
#to_a	Returns an array containing the items in enum.
#to_h	Returns the result of interpreting enum as a list of `[key, value]` pairs.
#uniq	Returns a new array by removing duplicate values in `self`.
#zip	Takes one element from enum and merges corresponding elements from each args.

Constructor Details

.new(begin, end, exclude_end=false) ⇒ `Range`

Constructs a range using the given #begin and #end. If the exclude_end parameter is omitted or is false, the range will include the end object; otherwise, it will be excluded.

[ GitHub ]

# File 'range.c', line 81


static VALUE
range_initialize(int argc, VALUE *argv, VALUE range)
{
    VALUE beg, end, flags;

    rb_scan_args(argc, argv, "21", &beg, &end, &flags);
    range_modify(range);
    range_init(range, beg, end, RBOOL(RTEST(flags)));
    return Qnil;
}

Instance Attribute Details

#exclude_end? ⇒ `Boolean` (readonly)

Returns true if the range excludes its end value.

(1..5).exclude_end?     #=> false
(1...5).exclude_end?    #=> true

[ GitHub ]

# File 'range.c', line 111


static VALUE
range_exclude_end_p(VALUE range)
{
    return EXCL(range) ? Qtrue : Qfalse;
}

Instance Method Details

#step(n = 1) {|obj| ... } ⇒ `Range` #step(n = 1) ⇒ Enumerator #step(n = 1) ⇒ `an_arithmetic_sequence` #%(n) ⇒ Enumerator #%(n) ⇒ `an_arithmetic_sequence`

Iterates over the range, passing each nth element to the block. If begin and end are numeric, n is added for each iteration. Otherwise #step invokes #succ to iterate through range elements.

If no block is given, an enumerator is returned instead. Especially, the enumerator is an ::Enumerator::ArithmeticSequence if begin and end of the range are numeric.

range = Xs.new(1)..Xs.new(10)
range.step(2) {|x| puts x}
puts
range.step(3) {|x| puts x}

produces:

 1 x
 3 xxx
 5 xxxxx
 7 xxxxxxx
 9 xxxxxxxxx

 1 x
 4 xxxx
 7 xxxxxxx
10 xxxxxxxxxx

See Range for the definition of class Xs.

[ GitHub ]

# File 'range.c', line 500


static VALUE
range_percent_step(VALUE range, VALUE step)
{
    return range_step(1, &step, range);
}

#==(obj) ⇒ `Boolean`

Returns true only if obj is a Range, has equivalent begin and end items (by comparing them with ==), and has the same #exclude_end? setting as the range.

(0..2) == (0..2)            #=> true
(0..2) == Range.new(0,2)    #=> true
(0..2) == (0...2)           #=> false

[ GitHub ]

# File 'range.c', line 146


static VALUE
range_eq(VALUE range, VALUE obj)
{
    if (range == obj)
	return Qtrue;
    if (!rb_obj_is_kind_of(obj, rb_cRange))
	return Qfalse;

    return rb_exec_recursive_paired(recursive_equal, range, obj, obj);
}

#===(obj) ⇒ `Boolean`

Returns true if obj is between begin and end of range, false otherwise (same as #cover?). Conveniently, === is the comparison operator used by case statements.

case 79
when 1..50   then   puts "low"
when 51..75  then   puts "medium"
when 76..100 then   puts "high"
end
# Prints "high"

case "2.6.5"
when ..."2.4" then puts "EOL"
when "2.4"..."2.5" then puts "maintenance"
when "2.5"..."2.7" then puts "stable"
when "2.7".. then puts "upcoming"
end
# Prints "stable"

[ GitHub ]

# File 'range.c', line 1410


static VALUE
range_eqq(VALUE range, VALUE val)
{
    VALUE ret = range_include_internal(range, val, 1);
    if (ret != Qundef) return ret;
    return r_cover_p(range, RANGE_BEG(range), RANGE_END(range), val);
}

#begin ⇒ Object

Returns the object that defines the beginning of the range.

(1..10).begin   #=> 1

[ GitHub ]

# File 'range.c', line 960


static VALUE
range_begin(VALUE range)
{
    return RANGE_BEG(range);
}

#bsearch {|obj| ... } ⇒ `value`

By using binary search, finds a value in range which meets the given condition in O(log n) where n is the size of the range.

You can use this method in two use cases: a find-minimum mode and a find-any mode. In either case, the elements of the range must be monotone (or sorted) with respect to the block.

In find-minimum mode (this is a good choice for typical use case), the block must return true or false, and there must be a value x so that:

the block returns false for any value which is less than x, and
the block returns true for any value which is greater than or equal to x.

If x is within the range, this method returns the value x. Otherwise, it returns nil.

ary = [0, 4, 7, 10, 12]
(0...ary.size).bsearch {|i| ary[i] >= 4 } #=> 1
(0...ary.size).bsearch {|i| ary[i] >= 6 } #=> 2
(0...ary.size).bsearch {|i| ary[i] >= 8 } #=> 3
(0...ary.size).bsearch {|i| ary[i] >= 100 } #=> nil

(0.0...Float::INFINITY).bsearch {|x| Math.log(x) >= 0 } #=> 1.0

In find-any mode (this behaves like libc’s bsearch(3)), the block must return a number, and there must be two values x and y (x <= y) so that:

the block returns a positive number for v if v < x,
the block returns zero for v if x <= v < y, and
the block returns a negative number for v if y <= v.

This method returns any value which is within the intersection of the given range and x…y (if any). If there is no value that satisfies the condition, it returns nil.

ary = [0, 100, 100, 100, 200]
(0..4).bsearch {|i| 100 - ary[i] } #=> 1, 2 or 3
(0..4).bsearch {|i| 300 - ary[i] } #=> nil
(0..4).bsearch {|i|  50 - ary[i] } #=> nil

You must not mix the two modes at a time; the block must always return either true/false, or always return a number. It is undefined which value is actually picked up at each iteration.

[ GitHub ]

# File 'range.c', line 656


static VALUE
range_bsearch(VALUE range)
{
    VALUE beg, end, satisfied = Qnil;
    int smaller;

    /* Implementation notes:
     * Floats are handled by mapping them to 64 bits integers.
     * Apart from sign issues, floats and their 64 bits integer have the
     * same order, assuming they are represented as exponent followed
     * by the mantissa. This is true with or without implicit bit.
     *
     * Finding the average of two ints needs to be careful about
     * potential overflow (since float to long can use 64 bits)
     * as well as the fact that -1/2 can be 0 or -1 in C89.
     *
     * Note that -0.0 is mapped to the same int as 0.0 as we don't want
     * (-1...0.0).bsearch to yield -0.0.
     */

#define BSEARCH(conv) \
    do { \
	RETURN_ENUMERATOR(range, 0, 0); \
	if (EXCL(range)) high--; \
	org_high = high; \
	while (low < high) { \
	    mid = ((high < 0) == (low < 0)) ? low + ((high - low) / 2) \
		: (low < -high) ? -((-1 - low - high)/2 + 1) : (low + high) / 2; \
	    BSEARCH_CHECK(conv(mid)); \
	    if (smaller) { \
		high = mid; \
	    } \
	    else { \
		low = mid + 1; \
	    } \
	} \
	if (low == org_high) { \
	    BSEARCH_CHECK(conv(low)); \
	    if (!smaller) return Qnil; \
	} \
	return satisfied; \
    } while (0)


    beg = RANGE_BEG(range);
    end = RANGE_END(range);

    if (FIXNUM_P(beg) && FIXNUM_P(end)) {
	long low = FIX2LONG(beg);
	long high = FIX2LONG(end);
	long mid, org_high;
	BSEARCH(INT2FIX);
    }
#if SIZEOF_DOUBLE == 8 && defined(HAVE_INT64_T)
    else if (RB_TYPE_P(beg, T_FLOAT) || RB_TYPE_P(end, T_FLOAT)) {
	int64_t low  = double_as_int64(NIL_P(beg) ? -HUGE_VAL : RFLOAT_VALUE(rb_Float(beg)));
	int64_t high = double_as_int64(NIL_P(end) ?  HUGE_VAL : RFLOAT_VALUE(rb_Float(end)));
	int64_t mid, org_high;
	BSEARCH(int64_as_double_to_num);
    }
#endif
    else if (is_integer_p(beg) && is_integer_p(end)) {
	RETURN_ENUMERATOR(range, 0, 0);
	return bsearch_integer_range(beg, end, EXCL(range));
    }
    else if (is_integer_p(beg) && NIL_P(end)) {
	VALUE diff = LONG2FIX(1);
	RETURN_ENUMERATOR(range, 0, 0);
	while (1) {
	    VALUE mid = rb_funcall(beg, '+', 1, diff);
	    BSEARCH_CHECK(mid);
	    if (smaller) {
		return bsearch_integer_range(beg, mid, 0);
	    }
	    diff = rb_funcall(diff, '*', 1, LONG2FIX(2));
	}
    }
    else if (NIL_P(beg) && is_integer_p(end)) {
	VALUE diff = LONG2FIX(-1);
	RETURN_ENUMERATOR(range, 0, 0);
	while (1) {
	    VALUE mid = rb_funcall(end, '+', 1, diff);
	    BSEARCH_CHECK(mid);
	    if (!smaller) {
		return bsearch_integer_range(mid, end, 0);
	    }
	    diff = rb_funcall(diff, '*', 1, LONG2FIX(2));
	}
    }
    else {
	rb_raise(rb_eTypeError, "can't do binary search for %s", rb_obj_classname(beg));
    }
    return range;
}

#count ⇒ Integer #count(item) ⇒ Integer #count {|obj| ... } ⇒ Integer

Identical to Enumerable#count, except it returns Infinity for endless ranges.

[ GitHub ]

# File 'range.c', line 1635


static VALUE
range_count(int argc, VALUE *argv, VALUE range)
{
    if (argc != 0) {
        /* It is odd for instance (1...).count(0) to return Infinity. Just let
         * it loop. */
        return rb_call_super(argc, argv);
    }
    else if (rb_block_given_p()) {
        /* Likewise it is odd for instance (1...).count {|x| x == 0 } to return
         * Infinity. Just let it loop. */
        return rb_call_super(argc, argv);
    }
    else if (NIL_P(RANGE_END(range))) {
        /* We are confident that the answer is Infinity. */
        return DBL2NUM(HUGE_VAL);
    }
    else if (NIL_P(RANGE_BEG(range))) {
        /* We are confident that the answer is Infinity. */
        return DBL2NUM(HUGE_VAL);
    }
    else {
        return rb_call_super(argc, argv);
    }
}

#cover?(obj) ⇒ `Boolean` #cover?(range) ⇒ `Boolean`

Returns true if obj is between the begin and end of the range.

This tests begin <= obj <= end when #exclude_end? is false and begin <= obj < end when #exclude_end? is true.

If called with a Range argument, returns true when the given range is covered by the receiver, by comparing the begin and end values. If the argument can be treated as a sequence, this method treats it that way. In the specific case of (a..b).cover?(c...d) with a <= c && b < d, the end of the sequence must be calculated, which may exhibit poor performance if c is non-numeric. Returns false if the begin value of the range is larger than the end value. Also returns false if one of the internal calls to <=> returns nil (indicating the objects are not comparable).

("a".."z").cover?("c")  #=> true
("a".."z").cover?("5")  #=> false
("a".."z").cover?("cc") #=> true
("a".."z").cover?(1)    #=> false
(1..5).cover?(2..3)     #=> true
(1..5).cover?(0..6)     #=> false
(1..5).cover?(1...6)    #=> true

[ GitHub ]

# File 'range.c', line 1521


static VALUE
range_cover(VALUE range, VALUE val)
{
    VALUE beg, end;

    beg = RANGE_BEG(range);
    end = RANGE_END(range);

    if (rb_obj_is_kind_of(val, rb_cRange)) {
        return RBOOL(r_cover_range_p(range, beg, end, val));
    }
    return r_cover_p(range, beg, end, val);
}

#each {|i| ... } ⇒ `Range` #each ⇒ Enumerator

Iterates over the elements of range, passing each in turn to the block.

The each method can only be used if the begin object of the range supports the succ method. A TypeError is raised if the object does not have succ method defined (like ::Float).

If no block is given, an enumerator is returned instead.

(10..15).each {|n| print n, ' ' }
# prints: 10 11 12 13 14 15

(2.5..5).each {|n| print n, ' ' }
# raises: TypeError: can't iterate from Float

[ GitHub ]

# File 'range.c', line 843


static VALUE
range_each(VALUE range)
{
    VALUE beg, end;
    long i, lim;

    RETURN_SIZED_ENUMERATOR(range, 0, 0, range_enum_size);

    beg = RANGE_BEG(range);
    end = RANGE_END(range);

    if (FIXNUM_P(beg) && NIL_P(end)) {
      fixnum_endless:
	i = FIX2LONG(beg);
	while (FIXABLE(i)) {
	    rb_yield(LONG2FIX(i++));
	}
	beg = LONG2NUM(i);
      bignum_endless:
	for (;; beg = rb_big_plus(beg, INT2FIX(1)))
	    rb_yield(beg);
    }
    else if (FIXNUM_P(beg) && FIXNUM_P(end)) { /* fixnums are special */
      fixnum_loop:
	lim = FIX2LONG(end);
	if (!EXCL(range))
	    lim += 1;
	for (i = FIX2LONG(beg); i < lim; i++) {
	    rb_yield(LONG2FIX(i));
	}
    }
    else if (RB_INTEGER_TYPE_P(beg) && (NIL_P(end) || RB_INTEGER_TYPE_P(end))) {
	if (SPECIAL_CONST_P(end) || RBIGNUM_POSITIVE_P(end)) { /* end >= FIXNUM_MIN */
	    if (!FIXNUM_P(beg)) {
		if (RBIGNUM_NEGATIVE_P(beg)) {
		    do {
			rb_yield(beg);
		    } while (!FIXNUM_P(beg = rb_big_plus(beg, INT2FIX(1))));
		    if (NIL_P(end)) goto fixnum_endless;
		    if (FIXNUM_P(end)) goto fixnum_loop;
		}
		else {
		    if (NIL_P(end)) goto bignum_endless;
		    if (FIXNUM_P(end)) return range;
		}
	    }
	    if (FIXNUM_P(beg)) {
		i = FIX2LONG(beg);
		do {
		    rb_yield(LONG2FIX(i));
		} while (POSFIXABLE(++i));
		beg = LONG2NUM(i);
	    }
	    ASSUME(!FIXNUM_P(beg));
	    ASSUME(!SPECIAL_CONST_P(end));
	}
	if (!FIXNUM_P(beg) && RBIGNUM_SIGN(beg) == RBIGNUM_SIGN(end)) {
	    if (EXCL(range)) {
		while (rb_big_cmp(beg, end) == INT2FIX(-1)) {
		    rb_yield(beg);
		    beg = rb_big_plus(beg, INT2FIX(1));
		}
	    }
	    else {
		VALUE c;
		while ((c = rb_big_cmp(beg, end)) != INT2FIX(1)) {
		    rb_yield(beg);
		    if (c == INT2FIX(0)) break;
		    beg = rb_big_plus(beg, INT2FIX(1));
		}
	    }
	}
    }
    else if (SYMBOL_P(beg) && (NIL_P(end) || SYMBOL_P(end))) { /* symbols are special */
	beg = rb_sym2str(beg);
	if (NIL_P(end)) {
	    rb_str_upto_endless_each(beg, sym_each_i, 0);
	}
	else {
	    rb_str_upto_each(beg, rb_sym2str(end), EXCL(range), sym_each_i, 0);
	}
    }
    else {
	VALUE tmp = rb_check_string_type(beg);

	if (!NIL_P(tmp)) {
	    if (!NIL_P(end)) {
		rb_str_upto_each(tmp, end, EXCL(range), each_i, 0);
	    }
	    else {
		rb_str_upto_endless_each(tmp, each_i, 0);
	    }
	}
	else {
	    if (!discrete_object_p(beg)) {
		rb_raise(rb_eTypeError, "can't iterate from %s",
			 rb_obj_classname(beg));
	    }
	    if (!NIL_P(end))
		range_each_func(range, each_i, 0);
	    else
		for (;; beg = rb_funcallv(beg, id_succ, 0, 0))
		    rb_yield(beg);
	}
    }
    return range;
}

#end ⇒ Object

Returns the object that defines the end of the range.

(1..10).end    #=> 10
(1...10).end   #=> 10

[ GitHub ]

# File 'range.c', line 978


static VALUE
range_end(VALUE range)
{
    return RANGE_END(range);
}

#to_a ⇒ Array #entries ⇒ Array

Alias for #to_a.

#eql?(obj) ⇒ `Boolean`

Returns true only if obj is a Range, has equivalent begin and end items (by comparing them with eql?), and has the same #exclude_end? setting as the range.

(0..2).eql?(0..2)            #=> true
(0..2).eql?(Range.new(0,2))  #=> true
(0..2).eql?(0...2)           #=> false

[ GitHub ]

# File 'range.c', line 200


static VALUE
range_eql(VALUE range, VALUE obj)
{
    if (range == obj)
	return Qtrue;
    if (!rb_obj_is_kind_of(obj, rb_cRange))
	return Qfalse;
    return rb_exec_recursive_paired(recursive_eql, range, obj, obj);
}

#first ⇒ Object #first(n) ⇒ Array

Returns the first object in the range, or an array of the first n elements.

(10..20).first     #=> 10
(10..20).first(3)  #=> [10, 11, 12]

[ GitHub ]

# File 'range.c', line 1012


static VALUE
range_first(int argc, VALUE *argv, VALUE range)
{
    VALUE n, ary[2];

    if (NIL_P(RANGE_BEG(range))) {
        rb_raise(rb_eRangeError, "cannot get the first element of beginless range");
    }
    if (argc == 0) return RANGE_BEG(range);

    rb_scan_args(argc, argv, "1", &n);
    ary[0] = n;
    ary[1] = rb_ary_new2(NUM2LONG(n));
    rb_block_call(range, idEach, 0, 0, first_i, (VALUE)ary);

    return ary[1];
}

#hash ⇒ Integer

Compute a hash-code for this range. Two ranges with equal begin and end points (using #eql?), and the same #exclude_end? value will generate the same hash-code.

#member?(obj) ⇒ `Boolean` #include?(obj) ⇒ `Boolean`

Alias for #member?.

#initialize_copy(orig)

This method is for internal use only.

[ GitHub ]

# File 'range.c', line 93


static VALUE
range_initialize_copy(VALUE range, VALUE orig)
{
    range_modify(range);
    rb_struct_init_copy(range, orig);
    return range;
}

#inspect ⇒ String

Convert this range object to a printable form (using #inspect to convert the begin and end objects).

[ GitHub ]

# File 'range.c', line 1376


static VALUE
range_inspect(VALUE range)
{
    return rb_exec_recursive(inspect_range, range, 0);
}

#last ⇒ Object #last(n) ⇒ Array

Returns the last object in the range, or an array of the last n elements.

Note that with no arguments last will return the object that defines the end of the range even if #exclude_end? is true.

(10..20).last      #=> 20
(10...20).last     #=> 20
(10..20).last(3)   #=> [18, 19, 20]
(10...20).last(3)  #=> [17, 18, 19]

[ GitHub ]

# File 'range.c', line 1100


static VALUE
range_last(int argc, VALUE *argv, VALUE range)
{
    VALUE b, e;

    if (NIL_P(RANGE_END(range))) {
        rb_raise(rb_eRangeError, "cannot get the last element of endless range");
    }
    if (argc == 0) return RANGE_END(range);

    b = RANGE_BEG(range);
    e = RANGE_END(range);
    if (RB_INTEGER_TYPE_P(b) && RB_INTEGER_TYPE_P(e) &&
        RB_LIKELY(rb_method_basic_definition_p(rb_cRange, idEach))) {
        return rb_int_range_last(argc, argv, range);
    }
    return rb_ary_last(argc, argv, rb_Array(range));
}

#max ⇒ Object #max {|a, b| ... } ⇒ Object #max(n) ⇒ Object #max(n) {|a, b| ... } ⇒ Object

Returns the maximum value in the range. Returns nil if the begin value of the range larger than the end value. Returns nil if the begin value of an exclusive range is equal to the end value.

Can be given an optional block to override the default comparison method a <=> b.

(10..20).max    #=> 20

[ GitHub ]

# File 'range.c', line 1183


static VALUE
range_max(int argc, VALUE *argv, VALUE range)
{
    VALUE e = RANGE_END(range);
    int nm = FIXNUM_P(e) || rb_obj_is_kind_of(e, rb_cNumeric);

    if (NIL_P(RANGE_END(range))) {
	rb_raise(rb_eRangeError, "cannot get the maximum of endless range");
    }

    if (rb_block_given_p() || (EXCL(range) && !nm) || argc) {
        if (NIL_P(RANGE_BEG(range))) {
            rb_raise(rb_eRangeError, "cannot get the maximum of beginless range with custom comparison method");
        }
        return rb_call_super(argc, argv);
    }
    else {
        struct cmp_opt_data cmp_opt = { 0, 0 };
        VALUE b = RANGE_BEG(range);
        int c = OPTIMIZED_CMP(b, e, cmp_opt);

        if (c > 0)
            return Qnil;
        if (EXCL(range)) {
            if (!RB_INTEGER_TYPE_P(e)) {
                rb_raise(rb_eTypeError, "cannot exclude non Integer end value");
            }
            if (c == 0) return Qnil;
            if (!RB_INTEGER_TYPE_P(b)) {
                rb_raise(rb_eTypeError, "cannot exclude end value with non Integer begin value");
            }
            if (FIXNUM_P(e)) {
                return LONG2NUM(FIX2LONG(e) - 1);
            }
            return rb_funcall(e, '-', 1, INT2FIX(1));
        }
        return e;
    }
}

#member?(obj) ⇒ `Boolean` #include?(obj) ⇒ `Boolean`
Also known as: #include?

Returns true if obj is an element of the range, false otherwise.

("a".."z").include?("g")   #=> true
("a".."z").include?("A")   #=> false
("a".."z").include?("cc")  #=> false

If you need to ensure obj is between #begin and #end, use #cover?

("a".."z").cover?("cc")  #=> true

If begin and end are numeric, #include? behaves like #cover?

(1..3).include?(1.5) # => true

[ GitHub ]

# File 'range.c', line 1440


static VALUE
range_include(VALUE range, VALUE val)
{
    VALUE ret = range_include_internal(range, val, 0);
    if (ret != Qundef) return ret;
    return rb_call_super(1, &val);
}

#min ⇒ Object #min {|a, b| ... } ⇒ Object #min(n) ⇒ Array #min(n) {|a, b| ... } ⇒ Array

Returns the minimum value in the range. Returns nil if the begin value of the range is larger than the end value. Returns nil if the begin value of an exclusive range is equal to the end value.

Can be given an optional block to override the default comparison method a <=> b.

(10..20).min    #=> 10

[ GitHub ]

# File 'range.c', line 1138


static VALUE
range_min(int argc, VALUE *argv, VALUE range)
{
    if (NIL_P(RANGE_BEG(range))) {
	rb_raise(rb_eRangeError, "cannot get the minimum of beginless range");
    }

    if (rb_block_given_p()) {
        if (NIL_P(RANGE_END(range))) {
            rb_raise(rb_eRangeError, "cannot get the minimum of endless range with custom comparison method");
        }
	return rb_call_super(argc, argv);
    }
    else if (argc != 0) {
	return range_first(argc, argv, range);
    }
    else {
	struct cmp_opt_data cmp_opt = { 0, 0 };
	VALUE b = RANGE_BEG(range);
	VALUE e = RANGE_END(range);
	int c = NIL_P(e) ? -1 : OPTIMIZED_CMP(b, e, cmp_opt);

	if (c > 0 || (c == 0 && EXCL(range)))
	    return Qnil;
	return b;
    }
}

#minmax ⇒ Array, Object #minmax {|a, b| ... } ⇒ Array, Object

Returns a two element array which contains the minimum and the maximum value in the range.

Can be given an optional block to override the default comparison method a <=> b.

[ GitHub ]

# File 'range.c', line 1235


static VALUE
range_minmax(VALUE range)
{
    if (rb_block_given_p()) {
        return rb_call_super(0, NULL);
    }
    return rb_assoc_new(
        rb_funcall(range, id_min, 0),
        rb_funcall(range, id_max, 0)
    );
}

#size ⇒ Numeric

Returns the number of elements in the range. Both the begin and the end of the Range must be ::Numeric, otherwise nil is returned.

(10..20).size    #=> 11
('a'..'z').size  #=> nil
(-Float::INFINITY..Float::INFINITY).size #=> Infinity

[ GitHub ]

# File 'range.c', line 777


static VALUE
range_size(VALUE range)
{
    VALUE b = RANGE_BEG(range), e = RANGE_END(range);
    if (rb_obj_is_kind_of(b, rb_cNumeric)) {
        if (rb_obj_is_kind_of(e, rb_cNumeric)) {
	    return ruby_num_interval_step_size(b, e, INT2FIX(1), EXCL(range));
        }
        if (NIL_P(e)) {
            return DBL2NUM(HUGE_VAL);
        }
    }
    else if (NIL_P(b)) {
        return DBL2NUM(HUGE_VAL);
    }

    return Qnil;
}

#step(n = 1) {|obj| ... } ⇒ `Range` #step(n = 1) ⇒ Enumerator #step(n = 1) ⇒ `an_arithmetic_sequence` #%(n) ⇒ Enumerator #%(n) ⇒ `an_arithmetic_sequence`

Iterates over the range, passing each nth element to the block. If begin and end are numeric, n is added for each iteration. Otherwise #step invokes #succ to iterate through range elements.

If no block is given, an enumerator is returned instead. Especially, the enumerator is an ::Enumerator::ArithmeticSequence if begin and end of the range are numeric.

range = Xs.new(1)..Xs.new(10)
range.step(2) {|x| puts x}
puts
range.step(3) {|x| puts x}

produces:

 1 x
 3 xxx
 5 xxxxx
 7 xxxxxxx
 9 xxxxxxxxx

 1 x
 4 xxxx
 7 xxxxxxx
10 xxxxxxxxxx

See Range for the definition of class Xs.

[ GitHub ]

# File 'range.c', line 392


static VALUE
range_step(int argc, VALUE *argv, VALUE range)
{
    VALUE b, e, step, tmp;

    b = RANGE_BEG(range);
    e = RANGE_END(range);
    step = (!rb_check_arity(argc, 0, 1) ? INT2FIX(1) : argv[0]);

    if (!rb_block_given_p()) {
        const VALUE b_num_p = rb_obj_is_kind_of(b, rb_cNumeric);
        const VALUE e_num_p = rb_obj_is_kind_of(e, rb_cNumeric);
        if ((b_num_p && (NIL_P(e) || e_num_p)) || (NIL_P(b) && e_num_p)) {
            return rb_arith_seq_new(range, ID2SYM(rb_frame_this_func()), argc, argv,
                    range_step_size, b, e, step, EXCL(range));
        }

        RETURN_SIZED_ENUMERATOR(range, argc, argv, range_step_size);
    }

    step = check_step_domain(step);

    if (FIXNUM_P(b) && NIL_P(e) && FIXNUM_P(step)) {
	long i = FIX2LONG(b), unit = FIX2LONG(step);
	do {
	    rb_yield(LONG2FIX(i));
	    i += unit;          /* FIXABLE+FIXABLE never overflow */
	} while (FIXABLE(i));
	b = LONG2NUM(i);

	for (;; b = rb_big_plus(b, step))
	    rb_yield(b);
    }
    else if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) { /* fixnums are special */
	long end = FIX2LONG(e);
	long i, unit = FIX2LONG(step);

	if (!EXCL(range))
	    end += 1;
	i = FIX2LONG(b);
	while (i < end) {
	    rb_yield(LONG2NUM(i));
	    if (i + unit < i) break;
	    i += unit;
	}

    }
    else if (SYMBOL_P(b) && (NIL_P(e) || SYMBOL_P(e))) { /* symbols are special */
	VALUE iter[2];
	iter[0] = INT2FIX(1);
	iter[1] = step;

	b = rb_sym2str(b);
	if (NIL_P(e)) {
	    rb_str_upto_endless_each(b, sym_step_i, (VALUE)iter);
	}
	else {
	    rb_str_upto_each(b, rb_sym2str(e), EXCL(range), sym_step_i, (VALUE)iter);
	}
    }
    else if (ruby_float_step(b, e, step, EXCL(range), TRUE)) {
	/* done */
    }
    else if (rb_obj_is_kind_of(b, rb_cNumeric) ||
	     !NIL_P(rb_check_to_integer(b, "to_int")) ||
	     !NIL_P(rb_check_to_integer(e, "to_int"))) {
	ID op = EXCL(range) ? '<' : idLE;
	VALUE v = b;
	int i = 0;

	while (NIL_P(e) || RTEST(rb_funcall(v, op, 1, e))) {
	    rb_yield(v);
	    i++;
	    v = rb_funcall(b, '+', 1, rb_funcall(INT2NUM(i), '*', 1, step));
	}
    }
    else {
	tmp = rb_check_string_type(b);

	if (!NIL_P(tmp)) {
	    VALUE iter[2];

	    b = tmp;
	    iter[0] = INT2FIX(1);
	    iter[1] = step;

	    if (NIL_P(e)) {
		rb_str_upto_endless_each(b, step_i, (VALUE)iter);
	    }
	    else {
		rb_str_upto_each(b, e, EXCL(range), step_i, (VALUE)iter);
	    }
	}
	else {
	    VALUE args[2];

	    if (!discrete_object_p(b)) {
		rb_raise(rb_eTypeError, "can't iterate from %s",
			 rb_obj_classname(b));
	    }
	    args[0] = INT2FIX(1);
	    args[1] = step;
	    range_each_func(range, step_i, (VALUE)args);
	}
    }
    return range;
}

#to_a ⇒ Array #entries ⇒ Array
Also known as: #entries

Returns an array containing the items in the range.

(1..7).to_a  #=> [1, 2, 3, 4, 5, 6, 7]
(1..).to_a   #=> RangeError: cannot convert endless range to an array

[ GitHub ]

# File 'range.c', line 807


static VALUE
range_to_a(VALUE range)
{
    if (NIL_P(RANGE_END(range))) {
	rb_raise(rb_eRangeError, "cannot convert endless range to an array");
    }
    return rb_call_super(0, 0);
}

#to_s ⇒ String

Convert this range object to a printable form (using #to_s to convert the begin and end objects).

[ GitHub ]

# File 'range.c', line 1330


static VALUE
range_to_s(VALUE range)
{
    VALUE str, str2;

    str = rb_obj_as_string(RANGE_BEG(range));
    str2 = rb_obj_as_string(RANGE_END(range));
    str = rb_str_dup(str);
    rb_str_cat(str, "...", EXCL(range) ? 3 : 2);
    rb_str_append(str, str2);

    return str;
}

Class: Range

Overview

Beginless/Endless Ranges

Custom Objects in Ranges

Class Method Summary

Instance Attribute Summary

Instance Method Summary

::Enumerable - Included

Constructor Details

.new(begin, end, exclude_end=false) ⇒ Range

Instance Attribute Details

#exclude_end? ⇒ Boolean (readonly)

Instance Method Details

#step(n = 1) {|obj| ... } ⇒ Range #step(n = 1) ⇒ Enumerator #step(n = 1) ⇒ an_arithmetic_sequence #%(n) ⇒ Enumerator #%(n) ⇒ an_arithmetic_sequence

#==(obj) ⇒ Boolean

#===(obj) ⇒ Boolean

#begin ⇒ Object

#bsearch {|obj| ... } ⇒ value

#count ⇒ Integer #count(item) ⇒ Integer #count {|obj| ... } ⇒ Integer

#cover?(obj) ⇒ Boolean #cover?(range) ⇒ Boolean

#each {|i| ... } ⇒ Range #each ⇒ Enumerator

#end ⇒ Object

#to_a ⇒ Array #entries ⇒ Array

#eql?(obj) ⇒ Boolean

#first ⇒ Object #first(n) ⇒ Array

#hash ⇒ Integer

#member?(obj) ⇒ Boolean #include?(obj) ⇒ Boolean

#initialize_copy(orig)

#inspect ⇒ String

#last ⇒ Object #last(n) ⇒ Array

#max ⇒ Object #max {|a, b| ... } ⇒ Object #max(n) ⇒ Object #max(n) {|a, b| ... } ⇒ Object

#member?(obj) ⇒ Boolean #include?(obj) ⇒ Boolean Also known as: #include?

#min ⇒ Object #min {|a, b| ... } ⇒ Object #min(n) ⇒ Array #min(n) {|a, b| ... } ⇒ Array

#minmax ⇒ Array, Object #minmax {|a, b| ... } ⇒ Array, Object

#size ⇒ Numeric

#step(n = 1) {|obj| ... } ⇒ Range #step(n = 1) ⇒ Enumerator #step(n = 1) ⇒ an_arithmetic_sequence #%(n) ⇒ Enumerator #%(n) ⇒ an_arithmetic_sequence

#to_a ⇒ Array #entries ⇒ Array Also known as: #entries

#to_s ⇒ String

`::Enumerable` - Included

.new(begin, end, exclude_end=false) ⇒ `Range`

#exclude_end? ⇒ `Boolean` (readonly)

#step(n = 1) {|obj| ... } ⇒ `Range` #step(n = 1) ⇒ Enumerator #step(n = 1) ⇒ `an_arithmetic_sequence` #%(n) ⇒ Enumerator #%(n) ⇒ `an_arithmetic_sequence`

#==(obj) ⇒ `Boolean`

#===(obj) ⇒ `Boolean`

#bsearch {|obj| ... } ⇒ `value`

#cover?(obj) ⇒ `Boolean` #cover?(range) ⇒ `Boolean`

#each {|i| ... } ⇒ `Range` #each ⇒ Enumerator

#eql?(obj) ⇒ `Boolean`

#member?(obj) ⇒ `Boolean` #include?(obj) ⇒ `Boolean`

#member?(obj) ⇒ `Boolean` #include?(obj) ⇒ `Boolean`
Also known as: #include?

#step(n = 1) {|obj| ... } ⇒ `Range` #step(n = 1) ⇒ Enumerator #step(n = 1) ⇒ `an_arithmetic_sequence` #%(n) ⇒ Enumerator #%(n) ⇒ `an_arithmetic_sequence`

#to_a ⇒ Array #entries ⇒ Array
Also known as: #entries