class Set - Documentation for Ruby 2.3.0 (original) (raw)

Set implements a collection of unordered values with no duplicates. This is a hybrid of Array's intuitive inter-operation facilities and Hash's fast lookup.

Set is easy to use with Enumerable objects (implementing each). Most of the initializer methods and binary operators accept generic Enumerable objects besides sets and arrays. An Enumerable object can be converted to Set using the to_set method.

Set uses Hash as storage, so you must note the following points:

Equality of elements is determined according to Object#eql? and Object#hash.
Set assumes that the identity of each element does not change while it is stored. Modifying an element of a set will render the set to an unreliable state.
When a string is to be stored, a frozen copy of the string is stored instead unless the original string is already frozen.

Comparison¶ ↑

The comparison operators <, >, <= and >= are implemented as shorthand for the {proper_,}{subset?,superset?} methods. However, the <=> operator is intentionally left out because not every pair of sets is comparable. ({x,y} vs. {x,z} for example)

Example¶ ↑

require 'set' s1 = Set.new [1, 2]
s2 = [1, 2].to_set
s1 == s2
s1.add("foo")
s1.merge([2, 6])
s1.subset? s2
s2.subset? s1

Akinori MUSHA knu@iDaemons.org (current maintainer)

Public Class Methods

[](*ary) click to toggle source

Creates a new set containing the given objects.

def self. new(ary) end

new(enum = nil) { |o| ... } 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.

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

Public Instance Methods

&(enum) click to toggle source

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

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

-(enum) click to toggle source

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

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

==(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?.

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

^(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)).

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.

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.

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

classify() { |o| ... } 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.

e.g.:

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

def classify block_given? or return enum_for(method)

h = {}

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

h end

clear() click to toggle source

Removes all elements and returns self.

def clear @hash.clear self end

collect!() { |o| ... } click to toggle source

Replaces the elements with ones returned by collect().

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

Also aliased as: map!

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() { |o| ... } click to toggle source

Deletes every element of the set for which block evaluates to true, and returns self.

def delete_if block_given? or return enum_for(method)

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

difference(enum)

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?.

e.g.:

require 'set' 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).

e.g.:

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

def divide(&func) func or return enum_for(method)

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.