класс Set

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

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

# File lib/set.rb, line 436
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 428
def ^(enum)
  n = Set.new(enum)
  each { |o| n.add(o) unless n.delete?(o) }
  n
end

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

# File lib/set.rb, line 320
def add?(o)
  add(o) unless include?(o)
end

# File lib/set.rb, line 470
def classify # :yields: o
  block_given? or return enum_for(__method__)

  h = {}

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

  h
end

# File lib/set.rb, line 144
def clear
  @hash.clear
  self
end

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

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

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

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

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

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

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

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

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

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

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

# File lib/set.rb, line 532
def inspect
  ids = (Thread.current[InspectKey] ||= [])

  if ids.include?(object_id)
    return sprintf('#<%s: {...}>', self.class.name)
  end

  ids << object_id
  begin
    return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
  ensure
    ids.pop
  end
end

# File lib/set.rb, line 279
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 349
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 384
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 259
def proper_subset?(set)
  case
  when set.instance_of?(self.class)
    @hash < set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size < set.size && all? { |o| set.include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

# File lib/set.rb, line 233
def proper_superset?(set)
  case
  when set.instance_of?(self.class)
    @hash > set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size > set.size && set.all? { |o| include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

# File lib/set.rb, line 366
def reject!(&block)
  block or return enum_for(__method__)
  n = size
  delete_if(&block)
  self if size != n
end

# File lib/set.rb, line 151
def replace(enum)
  if enum.instance_of?(self.class)
    @hash.replace(enum.instance_variable_get(:@hash))
    self
  else
    do_with_enum(enum)  # make sure enum is enumerable before calling clear
    clear
    merge(enum)
  end
end

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

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

# File lib/set.rb, line 246
def subset?(set)
  case
  when set.instance_of?(self.class)
    @hash <= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size <= set.size && all? { |o| set.include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

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

# File lib/set.rb, line 220
def superset?(set)
  case
  when set.instance_of?(self.class)
    @hash >= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size >= set.size && set.all? { |o| include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

# File lib/set.rb, line 163
def to_a
  @hash.keys
end

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