класс Set

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

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

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

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

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

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

  h = {}

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

  h
end

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

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

# File lib/set.rb, line 97
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

# File lib/set.rb, line 108
def compare_by_identity?
  @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
end

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

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

# File lib/set.rb, line 358
def delete_if
  block_given? or return enum_for(__method__) { size }
  # @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 315
def disjoint?(set)
  !intersect?(set)
end

# File lib/set.rb, line 523
def divide(&func)
  func or return enum_for(__method__) { size }

  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 322
def each(&block)
  block or return enum_for(__method__) { size }
  @hash.each_key(&block)
  self
end

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

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

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

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

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

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

# File lib/set.rb, line 557
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 297
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 369
def keep_if
  block_given? or return enum_for(__method__) { size }
  # @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 405
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 277
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 251
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 387
def reject!(&block)
  block or return enum_for(__method__) { size }
  n = size
  delete_if(&block)
  self if size != n
end

# File lib/set.rb, line 169
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 396
def select!(&block)
  block or return enum_for(__method__) { size }
  n = size
  keep_if(&block)
  self if size != n
end

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

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

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

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