Dispatch enter and leave events for ConstantOperatorWriteNode nodes and continue walking the tree.
Dispatch enter and leave events for ConstantPathWriteNode nodes and continue walking the tree.
Dispatch enter and leave events for InstanceVariableTargetNode nodes and continue walking the tree.
Inspect a InstanceVariableTargetNode node.
Create a new ConstantPathAndWriteNode node.
Create a new ConstantPathOrWriteNode node.
Create a new InstanceVariableOperatorWriteNode node.
Create a new InterpolatedMatchLastLineNode node.
Foo::Bar, = baz ^^^^^^^^
Foo::Bar, = baz ^^^^^^^^
Returns elements from self in a new array; does not modify self.
The objects included in the returned array are the elements of self selected by the given specifiers, each of which must be a numeric index or a Range.
In brief:
a = ['a', 'b', 'c', 'd'] # Index specifiers. a.values_at(2, 0, 2, 0) # => ["c", "a", "c", "a"] # May repeat. a.values_at(-4, -3, -2, -1) # => ["a", "b", "c", "d"] # Counts backwards if negative. a.values_at(-50, 50) # => [nil, nil] # Outside of self. # Range specifiers. a.values_at(1..3) # => ["b", "c", "d"] # From range.begin to range.end. a.values_at(1...3) # => ["b", "c"] # End excluded. a.values_at(3..1) # => [] # No such elements. a.values_at(-3..3) # => ["b", "c", "d"] # Negative range.begin counts backwards. a.values_at(-50..3) # Raises RangeError. a.values_at(1..-2) # => ["b", "c"] # Negative range.end counts backwards. a.values_at(1..-50) # => [] # No such elements. # Mixture of specifiers. a.values_at(2..3, 3, 0..1, 0) # => ["c", "d", "d", "a", "b", "a"]
With no specifiers given, returns a new empty array:
a = ['a', 'b', 'c', 'd'] a.values_at # => []
For each numeric specifier index, includes an element:
For each non-negative numeric specifier index that is in-range (less than self.size), includes the element at offset index:
a.values_at(0, 2) # => ["a", "c"] a.values_at(0.1, 2.9) # => ["a", "c"]
For each negative numeric index that is in-range (greater than or equal to - self.size), counts backwards from the end of self:
a.values_at(-1, -4) # => ["d", "a"]
The given indexes may be in any order, and may repeat:
a.values_at(2, 0, 1, 0, 2) # => ["c", "a", "b", "a", "c"]
For each index that is out-of-range, includes nil:
a.values_at(4, -5) # => [nil, nil]
For each Range specifier range, includes elements according to range.begin and range.end:
If both range.begin and range.end are non-negative and in-range (less than self.size), includes elements from index range.begin through range.end - 1 (if range.exclude_end?), or through range.end (otherwise):
a.values_at(1..2) # => ["b", "c"] a.values_at(1...2) # => ["b"]
If range.begin is negative and in-range (greater than or equal to - self.size), counts backwards from the end of self:
a.values_at(-2..3) # => ["c", "d"]
If range.begin is negative and out-of-range, raises an exception:
a.values_at(-5..3) # Raises RangeError.
If range.end is positive and out-of-range, extends the returned array with nil elements:
a.values_at(1..5) # => ["b", "c", "d", nil, nil]
If range.end is negative and in-range, counts backwards from the end of self:
a.values_at(1..-2) # => ["b", "c"]
If range.end is negative and out-of-range, returns an empty array:
a.values_at(1..-5) # => []
The given ranges may be in any order and may repeat:
a.values_at(2..3, 0..1, 2..3) # => ["c", "d", "a", "b", "c", "d"]
The given specifiers may be any mixture of indexes and ranges:
a.values_at(3, 1..2, 0, 2..3) # => ["d", "b", "c", "a", "c", "d"]
Related: see Methods for Fetching.
Removes the element of self at the given index, which must be an integer-convertible object.
When index is non-negative, deletes the element at offset index:
a = [:foo, 'bar', 2] a.delete_at(1) # => "bar" a # => [:foo, 2]
When index is negative, counts backward from the end of the array:
a = [:foo, 'bar', 2] a.delete_at(-2) # => "bar" a # => [:foo, 2]
When index is out of range, returns nil.
a = [:foo, 'bar', 2] a.delete_at(3) # => nil a.delete_at(-4) # => nil
Related: see Methods for Deleting.
With a block given, calls the block with each successive element of self; stops iterating if the block returns false or nil; returns a new array containing those elements for which the block returned a truthy value:
a = [0, 1, 2, 3, 4, 5] a.take_while {|element| element < 3 } # => [0, 1, 2] a.take_while {|element| true } # => [0, 1, 2, 3, 4, 5] a.take_while {|element| false } # => []
With no block given, returns a new Enumerator.
Does not modify self.
Related: see Methods for Fetching.
Returns whether self starts with any of the given string_or_regexp.
Matches patterns against the beginning of self. For each given string_or_regexp, the pattern is:
string_or_regexp itself, if it is a Regexp.
Regexp.quote(string_or_regexp), if string_or_regexp is a string.
Returns true if any pattern matches the beginning, false otherwise:
'hello'.start_with?('hell') # => true 'hello'.start_with?(/H/i) # => true 'hello'.start_with?('heaven', 'hell') # => true 'hello'.start_with?('heaven', 'paradise') # => false 'тест'.start_with?('т') # => true 'こんにちは'.start_with?('こ') # => true
Related: String#end_with?.
Returns the next-larger representable Float.
These examples show the internally stored values (64-bit hexadecimal) for each Float f and for the corresponding f.next_float:
f = 0.0 # 0x0000000000000000 f.next_float # 0x0000000000000001 f = 0.01 # 0x3f847ae147ae147b f.next_float # 0x3f847ae147ae147c
In the remaining examples here, the output is shown in the usual way (result to_s):
0.01.next_float # => 0.010000000000000002 1.0.next_float # => 1.0000000000000002 100.0.next_float # => 100.00000000000001 f = 0.01 (0..3).each_with_index {|i| printf "%2d %-20a %s\n", i, f, f.to_s; f = f.next_float }
Output:
0 0x1.47ae147ae147bp-7 0.01
1 0x1.47ae147ae147cp-7 0.010000000000000002
2 0x1.47ae147ae147dp-7 0.010000000000000004
3 0x1.47ae147ae147ep-7 0.010000000000000005
f = 0.0; 100.times { f += 0.1 }
f # => 9.99999999999998 # should be 10.0 in the ideal world.
10-f # => 1.9539925233402755e-14 # the floating point error.
10.0.next_float-10 # => 1.7763568394002505e-15 # 1 ulp (unit in the last place).
(10-f)/(10.0.next_float-10) # => 11.0 # the error is 11 ulp.
(10-f)/(10*Float::EPSILON) # => 8.8 # approximation of the above.
"%a" % 10 # => "0x1.4p+3"
"%a" % f # => "0x1.3fffffffffff5p+3" # the last hex digit is 5. 16 - 5 = 11 ulp.
Related: Float#prev_float