Class: Range

Inherits:
Object show all
Defined in:
lib/source/ruby.rb

Overview

A Range represents an interval – a set of values with a start and an end. Ranges may be constructed using the s..e and s...e literals, or with Range::new. Ranges constructed using .. run from the start 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"]

Ranges can be constructed using objects of any type, as long as the <=> comparison operator and the succ method (to return the next object in sequence) are defined.

class XChain
  attr :length

  def initialize(n)
    @length = n
  end

  def succ
    one_more = @length + 1
    XChain.new(one_more)
  end

  def <=>(other)
    @length <=> other.length
  end

  def inspect
    'x' * @length
  end
end

r = XChain.new(2)..XChain.new(5)    #=> xx..xxxxx
r.to_a                              #=> [xx, xxx, xxxx, xxxxx]
r.member? XChain.new(4)             #=> true

Instance Method Summary collapse

Constructor Details

#initialize(start, finish, exclusive = false) ⇒ Range

call-seq:

Range.new(start, end, exclusive=false) -> range

Constructs a range using the given start and end. If exclusive is omitted or is false, the range will include the end object; otherwise, it will be excluded.



4796
4797
4798
4799
4800
 
# File 'lib/source/ruby.rb', line 4796

def initialize(start,finish,exclusive=false)
  `this._start=start`
  `this._end=finish`
  `this._exclusive=exclusive`
end

Instance Method Details

#==(object) ⇒ Object

call-seq:

rng == obj -> true or false

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

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



4813
4814
4815
4816
 
# File 'lib/source/ruby.rb', line 4813

def ==(object)
  `if(object.constructor!==c$Range){return false;}`
  `this._start.m$_eql2(object._start)&&this._end.m$_eql2(object._end)&&this._exclusive==object._exclusive`
end

#===(obj) ⇒ Object

call-seq:

rng === obj       -> true or false
rng.include?(obj) -> true or false
rng.member?(obj)  -> true or false

Returns true if obj is an element of rng, false otherwise. Conveniently, === is the comparison operator used by case statements.

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

produces:

high



4837
4838
4839
4840
 
# File 'lib/source/ruby.rb', line 4837

def ===(obj)
  `var s=#{obj <=> `this._start`},e=#{obj <=> `this._end`}`
  `s==0||s==1?(this._exclusive?e==-1:e==-1||e==0):false`
end

#begin ⇒ Object

call-seq:

rng.begin -> obj
rng.first -> obj

Returns the first object in rng.

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



4850
4851
4852
 
# File 'lib/source/ruby.rb', line 4850

def begin
  `this._start`
end

#each ⇒ Object

FIX: Incomplete



4855
4856
4857
4858
4859
 
# File 'lib/source/ruby.rb', line 4855

def each
  `var start=this._start,end=this._end`
  `if(typeof(start)=='number'&&typeof(end)=='number'){if(!this._exclusive){end++;};for(var i=start;i<end;i++){#{yield `i`};};}`
  return self
end

#end ⇒ Object

call-seq:

rng.end  -> obj
rng.last -> obj

Returns the object that defines the end of rng.

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



4870
4871
4872
 
# File 'lib/source/ruby.rb', line 4870

def end()
  `this._end`
end

#eql?(object) ⇒ Boolean

call-seq:

rng.eql?(obj) -> true or false

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

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

Returns:

  • (Boolean) 


4894
4895
4896
4897
 
# File 'lib/source/ruby.rb', line 4894

def eql?(object)
  `if(object.constructor!==c$Range){return false;}`
  `this._start.m$eqlBool(object._start)&&this._end.m$eqlBool(object._end)&&this._exclusive==object._exclusive`
end

#exclude_end? ⇒ Boolean

call-seq:

rng.exclude_end? -> true or false

Returns true if rng excludes its end value.

Returns:

  • (Boolean) 


4879
4880
4881
 
# File 'lib/source/ruby.rb', line 4879

def exclude_end?
  `this._exclusive`
end

#first ⇒ Object

call-seq:

rng.begin -> obj
rng.first -> obj

Returns the first object in rng.

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



4907
4908
4909
 
# File 'lib/source/ruby.rb', line 4907

def first
  `this._start`
end

#hash ⇒ Object

FIX: Incomplete



4912
4913
 
# File 'lib/source/ruby.rb', line 4912

def hash # :nodoc:
end

#include?(obj) ⇒ Boolean

call-seq:

rng === obj       -> true or false
rng.include?(obj) -> true or false
rng.member?(obj)  -> true or false

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

(1..10).include?(10)    #=> true
(1...10).include?(10)   #=> false

Returns:

  • (Boolean) 


4925
4926
4927
4928
 
# File 'lib/source/ruby.rb', line 4925

def include?(obj)
  `var s=#{obj <=> `this._start`},e=#{obj <=> `this._end`}`
  `s==0||s==1?(this._exclusive?e==-1:e==-1||e==0):false`
end

#inspect ⇒ Object

call-seq:

rng.inspect -> string

Converts rng to a printable form (using inspect to convert the start and end objects).



4936
4937
4938
 
# File 'lib/source/ruby.rb', line 4936

def inspect
  `$q(''+this._start.m$inspect()+(this._exclusive?'...':'..')+this._end.m$inspect())`
end

#last ⇒ Object

call-seq:

rng.end  -> obj
rng.last -> obj

Returns the object that defines the end of rng.

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



4949
4950
4951
 
# File 'lib/source/ruby.rb', line 4949

def last
  `this._end`
end

#member?(obj) ⇒ Boolean

call-seq:

rng === obj       -> true or false
rng.include?(obj) -> true or false
rng.member?(obj)  -> true or false

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

(1..10).member?(10)    #=> true
(1...10).member?(10)   #=> false

Returns:

  • (Boolean) 


4963
4964
4965
4966
 
# File 'lib/source/ruby.rb', line 4963

def member?(obj)
  `var s=#{obj <=> `this._start`},e=#{obj <=> `this._end`}`
  `s==0||s==1?(this._exclusive?e==-1:e==-1||e==0):false`
end

#step ⇒ Object

FIX: Incomplete



4969
4970
 
# File 'lib/source/ruby.rb', line 4969

def step
end

#to_s ⇒ Object

call-seq:

rng.to_s -> string

Converts rng to a printable form.



4977
4978
4979
 
# File 'lib/source/ruby.rb', line 4977

def to_s
  `$q(''+this._start+(this._exclusive?'...':'..')+this._end)`
end