module Set::SubclassCompatible

This module is automatically included in subclasses of Set, to make them backwards compatible with the pure-Ruby set implementation used before Ruby 4. Users who want to use Set subclasses without this compatibility layer should subclass from Set::CoreSet.

Note that Set subclasses that access @hash are not compatible even with this support. Such subclasses must be updated to support Ruby 4.

Public Class Methods

new (enum = nil) { |o| ... }

Creates a new set containing the elements of the given enumerable object.

If a block is given, the elements of enum are preprocessed by the given block.

Set.new([1, 2])                       #=> #<Set: {1, 2}>
Set.new([1, 2, 1])                    #=> #<Set: {1, 2}>
Set.new([1, 'c', :s])                 #=> #<Set: {1, "c", :s}>
Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>

# File lib/set/subclass_compatible.rb, line 41
def initialize(enum = nil, &block) # :yields: o
  enum.nil? and return

  if block
    do_with_enum(enum) { |o| add(block[o]) }
  else
    merge(enum)
  end
end

Public Instance Methods

& (enum)

# File lib/set/subclass_compatible.rb, line 262
def &(enum)
  n = self.class.new
  if enum.is_a?(Set)
    if enum.size > size
      each { |o| n.add(o) if enum.include?(o) }
    else
      enum.each { |o| n.add(o) if include?(o) }
    end
  else
    do_with_enum(enum) { |o| n.add(o) if include?(o) }
  end
  n
end

Also aliased as: intersection

+ (enum)

Alias for: |

- (enum)

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

Also aliased as: difference

< (set)

Alias for: proper_subset?

<= (set)

Alias for: subset?

<=> (set)

# File lib/set/subclass_compatible.rb, line 161
def <=>(set)
  return unless set.is_a?(Set)

  case size <=> set.size
  when -1 then -1 if proper_subset?(set)
  when +1 then +1 if proper_superset?(set)
  else 0 if self.==(set)
  end
end

== (other)

Calls superclass method

# File lib/set/subclass_compatible.rb, line 283
def ==(other)
  if self.equal?(other)
    true
  elsif other.instance_of?(self.class)
    super
  elsif other.is_a?(Set) && self.size == other.size
    other.all? { |o| include?(o) }
  else
    false
  end
end

> (set)

Alias for: proper_superset?

>= (set)

Alias for: superset?

^ (enum)

# File lib/set/subclass_compatible.rb, line 277
def ^(enum)
  n = self.class.new(enum)
  each { |o| n.add(o) unless n.delete?(o) }
  n
end

| (enum)

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

Also aliased as: +, union

add? (o)

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

classify () { |i| ... }

# File lib/set/subclass_compatible.rb, line 300
def classify
  block_given? or return enum_for(__method__) { size }

  h = {}

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

  h
end

collect! () { |o| ... }

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

Also aliased as: map!

delete? (o)

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

delete_if (&block)

# File lib/set/subclass_compatible.rb, line 198
def delete_if(&block)
  block_given? or return enum_for(__method__) { size }
  select(&block).each { |o| delete(o) }
  self
end

difference (enum)

Alias for: -

disjoint? (set)

# File lib/set/subclass_compatible.rb, line 186
def disjoint?(set)
  !intersect?(set)
end

filter! (&block)

Alias for: select!

flatten ()

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

flatten! ()

# File lib/set/subclass_compatible.rb, line 109
def flatten!
  replace(flatten()) if any?(Set)
end

inspect ()

Returns a string containing a human-readable representation of the set (“#<Set: {element1, element2, …}>”).

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

Also aliased as: to_s

intersect? (set)

# File lib/set/subclass_compatible.rb, line 171
def intersect?(set)
  case set
  when Set
    if size < set.size
      any?(set)
    else
      set.any?(self)
    end
  when Enumerable
    set.any?(self)
  else
    raise ArgumentError, "value must be enumerable"
  end
end

intersection (enum)

Alias for: &

join (separator=nil)

# File lib/set/subclass_compatible.rb, line 312
def join(separator=nil)
  to_a.join(separator)
end

keep_if (&block)

# File lib/set/subclass_compatible.rb, line 204
def keep_if(&block)
  block_given? or return enum_for(__method__) { size }
  reject(&block).each { |o| delete(o) }
  self
end

map! ()

Alias for: collect!

merge (*enums, **nil)

Calls superclass method

# File lib/set/subclass_compatible.rb, line 234
def merge(*enums, **nil)
  enums.each do |enum|
    if enum.instance_of?(self.class)
      super(enum)
    else
      do_with_enum(enum) { |o| add(o) }
    end
  end

  self
end

proper_subset? (set)

Calls superclass method

# File lib/set/subclass_compatible.rb, line 149
def proper_subset?(set)
  case
  when set.instance_of?(self.class)
    super
  when set.is_a?(Set)
    size < set.size && all?(set)
  else
    raise ArgumentError, "value must be a set"
  end
end

Also aliased as: <

proper_superset? (set)

Calls superclass method

# File lib/set/subclass_compatible.rb, line 125
def proper_superset?(set)
  case
  when set.instance_of?(self.class)
    super
  when set.is_a?(Set)
    size > set.size && set.all?(self)
  else
    raise ArgumentError, "value must be a set"
  end
end

Also aliased as: >

reject! (&block)

# File lib/set/subclass_compatible.rb, line 218
def reject!(&block)
  block_given? or return enum_for(__method__) { size }
  n = size
  delete_if(&block)
  self if size != n
end

replace (enum)

Calls superclass method

# File lib/set/subclass_compatible.rb, line 62
def replace(enum)
  if enum.instance_of?(self.class)
    super
  else
    do_with_enum(enum)  # make sure enum is enumerable before calling clear
    clear
    merge(enum)
  end
end

select! (&block)

# File lib/set/subclass_compatible.rb, line 225
def select!(&block)
  block_given? or return enum_for(__method__) { size }
  n = size
  keep_if(&block)
  self if size != n
end

Also aliased as: filter!

subset? (set)

Calls superclass method

# File lib/set/subclass_compatible.rb, line 137
def subset?(set)
  case
  when set.instance_of?(self.class)
    super
  when set.is_a?(Set)
    size <= set.size && all?(set)
  else
    raise ArgumentError, "value must be a set"
  end
end

Also aliased as: <=

subtract (enum)

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

superset? (set)

Calls superclass method

# File lib/set/subclass_compatible.rb, line 113
def superset?(set)
  case
  when set.instance_of?(self.class)
    super
  when set.is_a?(Set)
    size >= set.size && set.all?(self)
  else
    raise ArgumentError, "value must be a set"
  end
end

Also aliased as: >=

to_s ()

Alias for: inspect

to_set (*args, &block)

# File lib/set/subclass_compatible.rb, line 72
def to_set(*args, &block)
  klass = if args.empty?
    Set
  else
    warn "passing arguments to Enumerable#to_set is deprecated", uplevel: 1
    args.shift
  end
  return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
  klass.new(self, *args, &block)
end

union (enum)

Alias for: |