Class: Set (Ruby 2.5.0) (original) (raw)

[](*ary) click to toggle source

Creates a new set containing the given objects.

Set[1, 2]
Set[1, 2, 1]
Set[1, 'c', :s]

def self. new(ary) end

new(enum = nil) click to toggle source

Creates a new set containing the elements of the given enumerable object.

If a block is given, the elements of enum are preprocessed by the given block.

Set.new([1, 2])
Set.new([1, 2, 1])
Set.new([1, 'c', :s])
Set.new(1..5)
Set.new([1, 2, 3]) { |x| x * x }

def initialize(enum = nil, &block) @hash ||= Hash.new(false)

enum.nil? and return

if block do_with_enum(enum) { |o| add(block[o]) } else merge(enum) end end

&(enum) click to toggle source

Returns a new set containing elements common to the set and the given enumerable object.

Set[1, 3, 5] & Set[3, 2, 1]
Set['a', 'b', 'z'] & ['a', 'b', 'c']

def &(enum) n = self.class.new do_with_enum(enum) { |o| n.add(o) if include?(o) } n end

+(enum) click to toggle source

Alias for: |

-(enum) click to toggle source

Returns a new set built by duplicating the set, removing every element that appears in the given enumerable object.

Set[1, 3, 5] - Set[1, 5]
Set['a', 'b', 'z'] - ['a', 'c']

def -(enum) dup.subtract(enum) end

<(set) click to toggle source

<<(o) click to toggle source

Alias for: add

<=(set) click to toggle source

==(other) click to toggle source

Returns true if two sets are equal. The equality of each couple of elements is defined according to Object#eql?.

Set[1, 2] == Set[2, 1]
Set[1, 3, 5] == Set[1, 5]
Set['a', 'b', 'c'] == Set['a', 'c', 'b']
Set['a', 'b', 'c'] == ['a', 'c', 'b']

def ==(other) if self.equal?(other) true elsif other.instance_of?(self.class) @hash == other.instance_variable_get(:@hash) elsif other.is_a?(Set) && self.size == other.size other.all? { |o| @hash.include?(o) } else false end end

===(o) click to toggle source

Returns true if the given object is a member of the set, and false otherwise.

Used in case statements:

require 'set'

case :apple when Set[:potato, :carrot] "vegetable" when Set[:apple, :banana] "fruit" end

Or by itself:

Set[1, 2, 3] === 2
Set[1, 2, 3] === 4

>(set) click to toggle source

>=(set) click to toggle source

^(enum) click to toggle source

Returns a new set containing elements exclusive between the set and the given enumerable object. (set ^ enum) is equivalent to ((set | enum) - (set & enum)).

Set[1, 2] ^ Set[2, 3]
Set[1, 'b', 'c'] ^ ['b', 'd']

def ^(enum) n = Set.new(enum) each { |o| n.add(o) unless n.delete?(o) } n end

add(o) click to toggle source

Adds the given object to the set and returns self. Use merge to add many elements at once.

Set[1, 2].add(3)
Set[1, 2].add([3, 4])
Set[1, 2].add(2)

def add(o) @hash[o] = true self end

Also aliased as: <<

add?(o) click to toggle source

Adds the given object to the set and returns self. If the object is already in the set, returns nil.

Set[1, 2].add?(3)
Set[1, 2].add?([3, 4])
Set[1, 2].add?(2)

def add?(o) add(o) unless include?(o) end

classify() click to toggle source

Classifies the set by the return value of the given block and returns a hash of {value => set of elements} pairs. The block is called once for each element of the set, passing the element as parameter.

require 'set' files = Set.new(Dir.glob("*.rb")) hash = files.classify { |f| File.mtime(f).year } hash

Returns an enumerator if no block is given.

def classify block_given? or return enum_for(method) { size }

h = {}

each { |i| (h[yield(i)] ||= self.class.new).add(i) }

h end

clear() click to toggle source

Removes all elements and returns self.

set = Set[1, 'c', :s]
set.clear
set

def clear @hash.clear self end

collect!() click to toggle source

Replaces the elements with ones returned by collect(). Returns an enumerator if no block is given.

def collect! block_given? or return enum_for(method) { size } set = self.class.new each { |o| set << yield(o) } replace(set) end

Also aliased as: map!

compare_by_identity() click to toggle source

Makes the set compare its elements by their identity and returns self. This method may not be supported by all subclasses of Set.

def compare_by_identity if @hash.respond_to?(:compare_by_identity) @hash.compare_by_identity self else raise NotImplementedError, "#{self.class.name}##{method} is not implemented" end end

compare_by_identity?() click to toggle source

Returns true if the set will compare its elements by their identity. Also see Set#compare_by_identity.

def compare_by_identity? @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity? end

delete(o) click to toggle source

Deletes the given object from the set and returns self. Use subtract to delete many items at once.

def delete(o) @hash.delete(o) self end

delete?(o) click to toggle source

Deletes the given object from the set and returns self. If the object is not in the set, returns nil.

def delete?(o) delete(o) if include?(o) end

delete_if() click to toggle source

Deletes every element of the set for which block evaluates to true, and returns self. Returns an enumerator if no block is given.

def delete_if block_given? or return enum_for(method) { size }

select { |o| yield o }.each { |o| @hash.delete(o) } self end

difference(enum) click to toggle source

Alias for: -

disjoint?(set) click to toggle source

Returns true if the set and the given set have no element in common. This method is the opposite of intersect?.

Set[1, 2, 3].disjoint? Set[3, 4]
Set[1, 2, 3].disjoint? Set[4, 5]

def disjoint?(set) !intersect?(set) end

divide(&func) click to toggle source

Divides the set into a set of subsets according to the commonality defined by the given block.

If the arity of the block is 2, elements o1 and o2 are in common if block.call(o1, o2) is true. Otherwise, elements o1 and o2 are in common if block.call(o1) == block.call(o2).

require 'set' numbers = Set[1, 3, 4, 6, 9, 10, 11] set = numbers.divide { |i,j| (i - j).abs == 1 } set

Returns an enumerator if no block is given.

def divide(&func) func or return enum_for(method) { size }

if func.arity == 2 require 'tsort'

class << dig = {}         
  include TSort

  alias tsort_each_node each_key
  def tsort_each_child(node, &block)
    fetch(node).each(&block)
  end
end

each { |u|
  dig[u] = a = []
  each{ |v| func.call(u, v) and a << v }
}

set = Set.new()
dig.each_strongly_connected_component { |css|
  set.add(self.class.new(css))
}
set

else Set.new(classify(&func).values) end end

each(&block) click to toggle source

Calls the given block once for each element in the set, passing the element as parameter. Returns an enumerator if no block is given.

def each(&block) block or return enum_for(method) { size } @hash.each_key(&block) self end

empty?() click to toggle source

Returns true if the set contains no elements.

def empty? @hash.empty? end

flatten() click to toggle source

Returns a new set that is a copy of the set, flattening each containing set recursively.

def flatten self.class.new.flatten_merge(self) end

flatten!() click to toggle source

Equivalent to Set#flatten, but replaces the receiver with the result in place. Returns nil if no modifications were made.

def flatten! replace(flatten()) if any? { |e| e.is_a?(Set) } end

include?(o) click to toggle source

Returns true if the set contains the given object.

Note that include? and member? do not test member equality using == as do other Enumerables.