класс Set

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

# File lib/set.rb, line 398
def -(enum)
  dup.subtract(enum)
end

# File lib/set.rb, line 423
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 lib/set.rb, line 415
def ^(enum)
  n = Set.new(enum)
  each { |o| if n.include?(o) then n.delete(o) else n.add(o) end }
  n
end

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

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

# File lib/set.rb, line 457
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 lib/set.rb, line 142
def clear
  @hash.clear
  self
end

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

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

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

# File lib/set.rb, line 324
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 lib/set.rb, line 274
def disjoint?(set)
  !intersect?(set)
end

# File lib/set.rb, line 486
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 lib/set.rb, line 281
def each(&block)
  block or return enum_for(__method__)
  @hash.each_key(&block)
  self
end

# File lib/set.rb, line 137
def empty?
  @hash.empty?
end

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

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

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

# File lib/set.rb, line 110
def initialize_clone(orig)
  super
  @hash = orig.instance_variable_get(:@hash).clone
end

# File lib/set.rb, line 104
def initialize_dup(orig)
  super
  @hash = orig.instance_variable_get(:@hash).dup
end

# File lib/set.rb, line 520
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 lib/set.rb, line 256
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 lib/set.rb, line 334
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 lib/set.rb, line 371
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 lib/set.rb, line 241
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 lib/set.rb, line 225
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 lib/set.rb, line 353
def reject!(&block)
  block or return enum_for(__method__)
  n = size
  delete_if(&block)
  size == n ? nil : self
end

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

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

# File lib/set.rb, line 131
def size
  @hash.size
end

# File lib/set.rb, line 233
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 lib/set.rb, line 383
def subtract(enum)
  do_with_enum(enum) { |o| delete(o) }
  self
end

# File lib/set.rb, line 217
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 lib/set.rb, line 161
def to_a
  @hash.keys
end

# File lib/set.rb, line 170
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 lib/set.rb, line 390
def |(enum)
  dup.merge(enum)
end