Set

 
 # File set.rb, line 71
def self.[](*ary)
 new(ary)
end
 

 
 # File set.rb, line 80
def initialize(enum = nil, &block) # :yields: o
 @hash ||= Hash.new
 enum.nil? and return
 if block
 do_with_enum(enum) { |o| add(block[o]) }
 else
 merge(enum)
 end
end
 

 
 # File set.rb, line 385
def &(enum)
 n = self.class.new
 do_with_enum(enum) { |o| n.add(o) if include?(o) }
 n
end
 

 
 # File set.rb, line 378
def -(enum)
 dup.subtract(enum)
end
 

 
 # File set.rb, line 403
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
 

 
 # File set.rb, line 395
def ^(enum)
 n = Set.new(enum)
 each { |o| if n.include?(o) then n.delete(o) else n.add(o) end }
 n
end
 

 
 # File set.rb, line 269
def add(o)
 @hash[o] = true
 self
end
 

 
 # File set.rb, line 277
def add?(o)
 if include?(o)
 nil
 else
 add(o)
 end
end
 

 
 # File set.rb, line 437
def classify # :yields: o
 block_given? or return enum_for(__method__)
 h = {}
 each { |i|
 x = yield(i)
 (h[x] ||= self.class.new).add(i)
 }
 h
end
 

 
 # File set.rb, line 135
def clear
 @hash.clear
 self
end
 

 
 # File set.rb, line 323
def collect!
 block_given? or return enum_for(__method__)
 set = self.class.new
 each { |o| set << yield(o) }
 replace(set)
end
 

 
 # File set.rb, line 287
def delete(o)
 @hash.delete(o)
 self
end
 

 
 # File set.rb, line 294
def delete?(o)
 if include?(o)
 delete(o)
 else
 nil
 end
end
 

 
 # File set.rb, line 304
def delete_if
 block_given? or return enum_for(__method__)
 # @hash.delete_if should be faster, but using it breaks the order
 # of enumeration in subclasses.
 select { |o| yield o }.each { |o| @hash.delete(o) }
 self
end
 

 
 # File set.rb, line 254
def disjoint?(set)
 !intersect?(set)
end
 

 
 # File set.rb, line 466
def divide(&func)
 func or return enum_for(__method__)
 if func.arity == 2
 require 'tsort'
 class << dig = {} # :nodoc:
 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
 

 
 # File set.rb, line 261
def each(&block)
 block or return enum_for(__method__)
 @hash.each_key(&block)
 self
end
 

 
 # File set.rb, line 130
def empty?
 @hash.empty?
end
 

 
 # File set.rb, line 189
def flatten
 self.class.new.flatten_merge(self)
end
 

 
 # File set.rb, line 195
def flatten!
 if detect { |e| e.is_a?(Set) }
 replace(flatten())
 else
 nil
 end
end
 

 
 # File set.rb, line 204
def include?(o)
 @hash.include?(o)
end
 

 
 # File set.rb, line 104
def initialize_copy(orig)
 @hash = orig.instance_variable_get(:@hash).dup
end
 

 
 # File set.rb, line 500
def inspect
 ids = (Thread.current[InspectKey] ||= [])
 if ids.include?(object_id)
 return sprintf('#<%s: {...}>', self.class.name)
 end
 begin
 ids << object_id
 return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
 ensure
 ids.pop
 end
end
 

 
 # File set.rb, line 243
def intersect?(set)
 set.is_a?(Set) or raise ArgumentError, "value must be a set"
 if size < set.size
 any? { |o| set.include?(o) }
 else
 set.any? { |o| include?(o) }
 end
end
 

 
 # File set.rb, line 314
def keep_if
 block_given? or return enum_for(__method__)
 # @hash.keep_if should be faster, but using it breaks the order of
 # enumeration in subclasses.
 reject { |o| yield o }.each { |o| @hash.delete(o) }
 self
end
 

 
 # File set.rb, line 351
def merge(enum)
 if enum.instance_of?(self.class)
 @hash.update(enum.instance_variable_get(:@hash))
 else
 do_with_enum(enum) { |o| add(o) }
 end
 self
end
 

 
 # File set.rb, line 234
def proper_subset?(set)
 set.is_a?(Set) or raise ArgumentError, "value must be a set"
 return false if set.size <= size
 all? { |o| set.include?(o) }
end
 

 
 # File set.rb, line 218
def proper_superset?(set)
 set.is_a?(Set) or raise ArgumentError, "value must be a set"
 return false if size <= set.size
 set.all? { |o| include?(o) }
end
 

 
 # File set.rb, line 333
def reject!(&block)
 block or return enum_for(__method__)
 n = size
 delete_if(&block)
 size == n ? nil : self
end
 

 
 # File set.rb, line 142
def replace(enum)
 if enum.instance_of?(self.class)
 @hash.replace(enum.instance_variable_get(:@hash))
 else
 clear
 merge(enum)
 end
 self
end
 

 
 # File set.rb, line 342
def select!(&block)
 block or return enum_for(__method__)
 n = size
 keep_if(&block)
 size == n ? nil : self
end
 

 
 # File set.rb, line 124
def size
 @hash.size
end
 

 
 # File set.rb, line 226
def subset?(set)
 set.is_a?(Set) or raise ArgumentError, "value must be a set"
 return false if set.size < size
 all? { |o| set.include?(o) }
end
 

 
 # File set.rb, line 363
def subtract(enum)
 do_with_enum(enum) { |o| delete(o) }
 self
end
 

 
 # File set.rb, line 210
def superset?(set)
 set.is_a?(Set) or raise ArgumentError, "value must be a set"
 return false if size < set.size
 set.all? { |o| include?(o) }
end
 

 
 # File set.rb, line 154
def to_a
 @hash.keys
end
 

 
 # File set.rb, line 163
def to_set(klass = Set, *args, &block)
 return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
 klass.new(self, *args, &block)
end
 

 
 # File set.rb, line 370
def |(enum)
 dup.merge(enum)
end