Class Set < Object

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

# File lib/set.rb, line 73
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 lib/set.rb, line 350
def &(enum)
  n = self.class.new
  do_with_enum(enum) { |o| n.add(o) if include?(o) }
  n
end

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

# File lib/set.rb, line 368
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 360
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 238
def add(o)
  @hash[o] = true
  self
end

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

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

# File lib/set.rb, line 288
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 256
def delete(o)
  @hash.delete(o)
  self
end

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

# File lib/set.rb, line 273
def delete_if
  block_given? or return enum_for(__method__)
  to_a.each { |o| @hash.delete(o) if yield(o) }
  self
end

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

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

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

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

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

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

# File lib/set.rb, line 465
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 281
def keep_if
  block_given? or return enum_for(__method__)
  to_a.each { |o| @hash.delete(o) unless yield(o) }
  self
end

# File lib/set.rb, line 316
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 220
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 204
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 298
def reject!(&block)
  block or return enum_for(__method__)
  n = size
  delete_if(&block)
  size == n ? nil : self
end

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

  self
end

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

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

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

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

# File lib/set.rb, line 335
def |(enum)
  dup.merge(enum)
end