Results for: "module_function"

Build a diagnostic from the given prism parse warning.

Return a String indicating who caused this request to be added (only valid for implicit requests)

Enumerates trusted certificates.

Loads the given certificate_file

Returns the count of elements in self.

Removes zero or more elements from self.

When no block is given, removes from self each element ele such that ele == obj; returns the last deleted element:

s1 = 'bar'; s2 = 'bar'
a = [:foo, s1, 2, s2]
a.delete('bar') # => "bar"
a # => [:foo, 2]

Returns nil if no elements removed.

When a block is given, removes from self each element ele such that ele == obj.

If any such elements are found, ignores the block and returns the last deleted element:

s1 = 'bar'; s2 = 'bar'
a = [:foo, s1, 2, s2]
deleted_obj = a.delete('bar') {|obj| fail 'Cannot happen' }
a # => [:foo, 2]

If no such elements are found, returns the block’s return value:

a = [:foo, 'bar', 2]
a.delete(:nosuch) {|obj| "#{obj} not found" } # => "nosuch not found"

Removes all elements from self:

a = [:foo, 'bar', 2]
a.clear # => []

When called with positive Integer argument count and a block, calls the block with each element, then does so again, until it has done so count times; returns nil:

output = []
[0, 1].cycle(2) {|element| output.push(element) } # => nil
output # => [0, 1, 0, 1]

If count is zero or negative, does not call the block:

[0, 1].cycle(0) {|element| fail 'Cannot happen' } # => nil
[0, 1].cycle(-1) {|element| fail 'Cannot happen' } # => nil

When a block is given, and argument is omitted or nil, cycles forever:

# Prints 0 and 1 forever.
[0, 1].cycle {|element| puts element }
[0, 1].cycle(nil) {|element| puts element }

When no block is given, returns a new Enumerator:

[0, 1].cycle(2) # => #<Enumerator: [0, 1]:cycle(2)>
[0, 1].cycle # => # => #<Enumerator: [0, 1]:cycle>
[0, 1].cycle.first(5) # => [0, 1, 0, 1, 0]

Shuffles the elements of self in place.

a = [1, 2, 3] #=> [1, 2, 3]
a.shuffle!    #=> [2, 3, 1]
a             #=> [2, 3, 1]

The optional random argument will be used as the random number generator:

a.shuffle!(random: Random.new(1))  #=> [1, 3, 2]

Returns a new array with elements of self shuffled.

a = [1, 2, 3] #=> [1, 2, 3]
a.shuffle     #=> [2, 3, 1]
a             #=> [1, 2, 3]

The optional random argument will be used as the random number generator:

a.shuffle(random: Random.new(1))  #=> [1, 3, 2]

Returns random elements from self.

When no arguments are given, returns a random element from self:

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a.sample # => 3
a.sample # => 8

If self is empty, returns nil.

When argument n is given, returns a new Array containing n random elements from self:

a.sample(3) # => [8, 9, 2]
a.sample(6) # => [9, 6, 10, 3, 1, 4]

Returns no more than a.size elements (because no new duplicates are introduced):

a.sample(a.size * 2) # => [6, 4, 1, 8, 5, 9, 10, 2, 3, 7]

But self may contain duplicates:

a = [1, 1, 1, 2, 2, 3]
a.sample(a.size * 2) # => [1, 1, 3, 2, 1, 2]

The argument n must be a non-negative numeric value. The order of the result array is unrelated to the order of self. Returns a new empty Array if self is empty.

The optional random argument will be used as the random number generator:

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a.sample(random: Random.new(1))     #=> 6
a.sample(4, random: Random.new(1))  #=> [6, 10, 9, 2]

Returns true if self is an odd number, false otherwise.

Returns the argument (angle) for self in radians; see polar coordinates:

Complex.polar(3, Math::PI/2).arg  # => 1.57079632679489660

If self was created with rectangular coordinates, the returned value is computed, and may be inexact:

Complex.polar(1, 1.0/3).arg # => 0.33333333333333326

Returns zero if self is positive, Math::PI otherwise.