diff options
Diffstat (limited to 'lib/set.rb')
| -rw-r--r-- | lib/set.rb | 860 |
1 files changed, 0 insertions, 860 deletions
diff --git a/lib/set.rb b/lib/set.rb deleted file mode 100644 index a515dacb0e..0000000000 --- a/lib/set.rb +++ /dev/null @@ -1,860 +0,0 @@ -# frozen_string_literal: true -# :markup: markdown -# -# set.rb - defines the Set class -# -# Copyright (c) 2002-2020 Akinori MUSHA <knu@iDaemons.org> -# -# Documentation by Akinori MUSHA and Gavin Sinclair. -# -# All rights reserved. You can redistribute and/or modify it under the same -# terms as Ruby. - - -## -# This library provides the Set class, which deals with a collection -# of unordered values with no duplicates. It is a hybrid of Array's -# intuitive inter-operation facilities and Hash's fast lookup. -# -# The method `to_set` is added to Enumerable for convenience. -# -# Set implements a collection of unordered values with no duplicates. -# This is a hybrid of Array's intuitive inter-operation facilities and -# Hash's fast lookup. -# -# Set is easy to use with Enumerable objects (implementing `each`). -# Most of the initializer methods and binary operators accept generic -# Enumerable objects besides sets and arrays. An Enumerable object -# can be converted to Set using the `to_set` method. -# -# Set uses Hash as storage, so you must note the following points: -# -# * Equality of elements is determined according to Object#eql? and -# Object#hash. Use Set#compare_by_identity to make a set compare -# its elements by their identity. -# * Set assumes that the identity of each element does not change -# while it is stored. Modifying an element of a set will render the -# set to an unreliable state. -# * When a string is to be stored, a frozen copy of the string is -# stored instead unless the original string is already frozen. -# -# ## Comparison -# -# The comparison operators `<`, `>`, `<=`, and `>=` are implemented as -# shorthand for the {proper_,}{subset?,superset?} methods. The `<=>` -# operator reflects this order, or return `nil` for sets that both -# have distinct elements (`{x, y}` vs. `{x, z}` for example). -# -# ## Example -# -# ```ruby -# require 'set' -# s1 = Set[1, 2] #=> #<Set: {1, 2}> -# s2 = [1, 2].to_set #=> #<Set: {1, 2}> -# s1 == s2 #=> true -# s1.add("foo") #=> #<Set: {1, 2, "foo"}> -# s1.merge([2, 6]) #=> #<Set: {1, 2, "foo", 6}> -# s1.subset?(s2) #=> false -# s2.subset?(s1) #=> true -# ``` -# -# ## Contact -# -# - Akinori MUSHA <<knu@iDaemons.org>> (current maintainer) -# -# ## What's Here -# -# First, what's elsewhere. \Class \Set: -# -# - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here]. -# - Includes {module Enumerable}[rdoc-ref:Enumerable@What-27s+Here], -# which provides dozens of additional methods. -# -# In particular, class \Set does not have many methods of its own -# for fetching or for iterating. -# Instead, it relies on those in \Enumerable. -# -# Here, class \Set provides methods that are useful for: -# -# - [Creating a Set](#class-Set-label-Methods+for+Creating+a+Set) -# - [Set Operations](#class-Set-label-Methods+for+Set+Operations) -# - [Comparing](#class-Set-label-Methods+for+Comparing) -# - [Querying](#class-Set-label-Methods+for+Querying) -# - [Assigning](#class-Set-label-Methods+for+Assigning) -# - [Deleting](#class-Set-label-Methods+for+Deleting) -# - [Converting](#class-Set-label-Methods+for+Converting) -# - [Iterating](#class-Set-label-Methods+for+Iterating) -# - [And more....](#class-Set-label-Other+Methods) -# -# ### Methods for Creating a \Set -# -# - ::[]: -# Returns a new set containing the given objects. -# - ::new: -# Returns a new set containing either the given objects -# (if no block given) or the return values from the called block -# (if a block given). -# -# ### Methods for \Set Operations -# -# - [|](#method-i-7C) (aliased as #union and #+): -# Returns a new set containing all elements from +self+ -# and all elements from a given enumerable (no duplicates). -# - [&](#method-i-26) (aliased as #intersection): -# Returns a new set containing all elements common to +self+ -# and a given enumerable. -# - [-](#method-i-2D) (aliased as #difference): -# Returns a copy of +self+ with all elements -# in a given enumerable removed. -# - [\^](#method-i-5E): -# Returns a new set containing all elements from +self+ -# and a given enumerable except those common to both. -# -# ### Methods for Comparing -# -# - [<=>](#method-i-3C-3D-3E): -# Returns -1, 0, or 1 as +self+ is less than, equal to, -# or greater than a given object. -# - [==](#method-i-3D-3D): -# Returns whether +self+ and a given enumerable are equal, -# as determined by Object#eql?. -# - \#compare_by_identity?: -# Returns whether the set considers only identity -# when comparing elements. -# -# ### Methods for Querying -# -# - \#length (aliased as #size): -# Returns the count of elements. -# - \#empty?: -# Returns whether the set has no elements. -# - \#include? (aliased as #member? and #===): -# Returns whether a given object is an element in the set. -# - \#subset? (aliased as [<=](#method-i-3C-3D)): -# Returns whether a given object is a subset of the set. -# - \#proper_subset? (aliased as [<](#method-i-3C)): -# Returns whether a given enumerable is a proper subset of the set. -# - \#superset? (aliased as [>=](#method-i-3E-3D])): -# Returns whether a given enumerable is a superset of the set. -# - \#proper_superset? (aliased as [>](#method-i-3E)): -# Returns whether a given enumerable is a proper superset of the set. -# - \#disjoint?: -# Returns +true+ if the set and a given enumerable -# have no common elements, +false+ otherwise. -# - \#intersect?: -# Returns +true+ if the set and a given enumerable: -# have any common elements, +false+ otherwise. -# - \#compare_by_identity?: -# Returns whether the set considers only identity -# when comparing elements. -# -# ### Methods for Assigning -# -# - \#add (aliased as #<<): -# Adds a given object to the set; returns +self+. -# - \#add?: -# If the given object is not an element in the set, -# adds it and returns +self+; otherwise, returns +nil+. -# - \#merge: -# Adds each given object to the set; returns +self+. -# - \#replace: -# Replaces the contents of the set with the contents -# of a given enumerable. -# -# ### Methods for Deleting -# -# - \#clear: -# Removes all elements in the set; returns +self+. -# - \#delete: -# Removes a given object from the set; returns +self+. -# - \#delete?: -# If the given object is an element in the set, -# removes it and returns +self+; otherwise, returns +nil+. -# - \#subtract: -# Removes each given object from the set; returns +self+. -# - \#delete_if - Removes elements specified by a given block. -# - \#select! (aliased as #filter!): -# Removes elements not specified by a given block. -# - \#keep_if: -# Removes elements not specified by a given block. -# - \#reject! -# Removes elements specified by a given block. -# -# ### Methods for Converting -# -# - \#classify: -# Returns a hash that classifies the elements, -# as determined by the given block. -# - \#collect! (aliased as #map!): -# Replaces each element with a block return-value. -# - \#divide: -# Returns a hash that classifies the elements, -# as determined by the given block; -# differs from #classify in that the block may accept -# either one or two arguments. -# - \#flatten: -# Returns a new set that is a recursive flattening of +self+. -# \#flatten!: -# Replaces each nested set in +self+ with the elements from that set. -# - \#inspect (aliased as #to_s): -# Returns a string displaying the elements. -# - \#join: -# Returns a string containing all elements, converted to strings -# as needed, and joined by the given record separator. -# - \#to_a: -# Returns an array containing all set elements. -# - \#to_set: -# Returns +self+ if given no arguments and no block; -# with a block given, returns a new set consisting of block -# return values. -# -# ### Methods for Iterating -# -# - \#each: -# Calls the block with each successive element; returns +self+. -# -# ### Other Methods -# -# - \#reset: -# Resets the internal state; useful if an object -# has been modified while an element in the set. -# -class Set - include Enumerable - - # Creates a new set containing the given objects. - # - # Set[1, 2] # => #<Set: {1, 2}> - # Set[1, 2, 1] # => #<Set: {1, 2}> - # Set[1, 'c', :s] # => #<Set: {1, "c", :s}> - def self.[](*ary) - new(ary) - end - - # 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}> - def initialize(enum = nil, &block) # :yields: o - @hash ||= Hash.new(false) - - enum.nil? and return - - if block - do_with_enum(enum) { |o| add(block[o]) } - else - merge(enum) - end - end - - # Makes the set compare its elements by their identity and returns - # self. This method may not be supported by all subclasses of Set. - 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 - - # Returns true if the set will compare its elements by their - # identity. Also see Set#compare_by_identity. - def compare_by_identity? - @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity? - end - - def do_with_enum(enum, &block) # :nodoc: - if enum.respond_to?(:each_entry) - enum.each_entry(&block) if block - elsif enum.respond_to?(:each) - enum.each(&block) if block - else - raise ArgumentError, "value must be enumerable" - end - end - private :do_with_enum - - # Dup internal hash. - def initialize_dup(orig) - super - @hash = orig.instance_variable_get(:@hash).dup - end - - if Kernel.instance_method(:initialize_clone).arity != 1 - # Clone internal hash. - def initialize_clone(orig, **options) - super - @hash = orig.instance_variable_get(:@hash).clone(**options) - end - else - # Clone internal hash. - def initialize_clone(orig) - super - @hash = orig.instance_variable_get(:@hash).clone - end - end - - def freeze # :nodoc: - @hash.freeze - super - end - - # Returns the number of elements. - def size - @hash.size - end - alias length size - - # Returns true if the set contains no elements. - def empty? - @hash.empty? - end - - # Removes all elements and returns self. - # - # set = Set[1, 'c', :s] #=> #<Set: {1, "c", :s}> - # set.clear #=> #<Set: {}> - # set #=> #<Set: {}> - def clear - @hash.clear - self - end - - # Replaces the contents of the set with the contents of the given - # enumerable object and returns self. - # - # set = Set[1, 'c', :s] #=> #<Set: {1, "c", :s}> - # set.replace([1, 2]) #=> #<Set: {1, 2}> - # set #=> #<Set: {1, 2}> - 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 - - # Converts the set to an array. The order of elements is uncertain. - # - # Set[1, 2].to_a #=> [1, 2] - # Set[1, 'c', :s].to_a #=> [1, "c", :s] - def to_a - @hash.keys - end - - # Returns self if no arguments are given. Otherwise, converts the - # set to another with `klass.new(self, *args, &block)`. - # - # In subclasses, returns `klass.new(self, *args, &block)` unless - # overridden. - 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 - - def flatten_merge(set, seen = Set.new) # :nodoc: - set.each { |e| - if e.is_a?(Set) - if seen.include?(e_id = e.object_id) - raise ArgumentError, "tried to flatten recursive Set" - end - - seen.add(e_id) - flatten_merge(e, seen) - seen.delete(e_id) - else - add(e) - end - } - - self - end - protected :flatten_merge - - # Returns a new set that is a copy of the set, flattening each - # containing set recursively. - def flatten - self.class.new.flatten_merge(self) - end - - # Equivalent to Set#flatten, but replaces the receiver with the - # result in place. Returns nil if no modifications were made. - def flatten! - replace(flatten()) if any? { |e| e.is_a?(Set) } - end - - # Returns true if the set contains the given object. - # - # Note that <code>include?</code> and <code>member?</code> do not test member - # equality using <code>==</code> as do other Enumerables. - # - # See also Enumerable#include? - def include?(o) - @hash[o] - end - alias member? include? - - # Returns true if the set is a superset of the given set. - def superset?(set) - case - when set.instance_of?(self.class) && @hash.respond_to?(:>=) - @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 - alias >= superset? - - # Returns true if the set is a proper superset of the given set. - def proper_superset?(set) - case - when set.instance_of?(self.class) && @hash.respond_to?(:>) - @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 - alias > proper_superset? - - # Returns true if the set is a subset of the given set. - def subset?(set) - case - when set.instance_of?(self.class) && @hash.respond_to?(:<=) - @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 - alias <= subset? - - # Returns true if the set is a proper subset of the given set. - def proper_subset?(set) - case - when set.instance_of?(self.class) && @hash.respond_to?(:<) - @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 - alias < proper_subset? - - # Returns 0 if the set are equal, - # -1 / +1 if the set is a proper subset / superset of the given set, - # or nil if they both have unique elements. - 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 - - # Returns true if the set and the given enumerable have at least one - # element in common. - # - # Set[1, 2, 3].intersect? Set[4, 5] #=> false - # Set[1, 2, 3].intersect? Set[3, 4] #=> true - # Set[1, 2, 3].intersect? 4..5 #=> false - # Set[1, 2, 3].intersect? [3, 4] #=> true - def intersect?(set) - case set - when Set - if size < set.size - any? { |o| set.include?(o) } - else - set.any? { |o| include?(o) } - end - when Enumerable - set.any? { |o| include?(o) } - else - raise ArgumentError, "value must be enumerable" - end - end - - # Returns true if the set and the given enumerable have - # no element in common. This method is the opposite of `intersect?`. - # - # Set[1, 2, 3].disjoint? Set[3, 4] #=> false - # Set[1, 2, 3].disjoint? Set[4, 5] #=> true - # Set[1, 2, 3].disjoint? [3, 4] #=> false - # Set[1, 2, 3].disjoint? 4..5 #=> true - def disjoint?(set) - !intersect?(set) - end - - # Calls the given block once for each element in the set, passing - # the element as parameter. Returns an enumerator if no block is - # given. - def each(&block) - block_given? or return enum_for(__method__) { size } - @hash.each_key(&block) - self - end - - # Adds the given object to the set and returns self. Use `merge` to - # add many elements at once. - # - # Set[1, 2].add(3) #=> #<Set: {1, 2, 3}> - # Set[1, 2].add([3, 4]) #=> #<Set: {1, 2, [3, 4]}> - # Set[1, 2].add(2) #=> #<Set: {1, 2}> - def add(o) - @hash[o] = true - self - end - alias << add - - # Adds the given object to the set and returns self. If the - # object is already in the set, returns nil. - # - # Set[1, 2].add?(3) #=> #<Set: {1, 2, 3}> - # Set[1, 2].add?([3, 4]) #=> #<Set: {1, 2, [3, 4]}> - # Set[1, 2].add?(2) #=> nil - def add?(o) - add(o) unless include?(o) - end - - # Deletes the given object from the set and returns self. Use - # `subtract` to delete many items at once. - def delete(o) - @hash.delete(o) - self - end - - # Deletes the given object from the set and returns self. If the - # object is not in the set, returns nil. - def delete?(o) - delete(o) if include?(o) - end - - # Deletes every element of the set for which block evaluates to - # true, and returns self. Returns an enumerator if no block is - # given. - 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 - - # Deletes every element of the set for which block evaluates to - # false, and returns self. Returns an enumerator if no block is - # given. - 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 - - # Replaces the elements with ones returned by `collect()`. - # Returns an enumerator if no block is given. - def collect! - block_given? or return enum_for(__method__) { size } - set = self.class.new - each { |o| set << yield(o) } - replace(set) - end - alias map! collect! - - # Equivalent to Set#delete_if, but returns nil if no changes were - # made. Returns an enumerator if no block is given. - def reject!(&block) - block_given? or return enum_for(__method__) { size } - n = size - delete_if(&block) - self if size != n - end - - # Equivalent to Set#keep_if, but returns nil if no changes were - # made. Returns an enumerator if no block is given. - def select!(&block) - block_given? or return enum_for(__method__) { size } - n = size - keep_if(&block) - self if size != n - end - - # Equivalent to Set#select! - alias filter! select! - - # Merges the elements of the given enumerable object to the set and - # returns self. - 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 - - # Deletes every element that appears in the given enumerable object - # and returns self. - def subtract(enum) - do_with_enum(enum) { |o| delete(o) } - self - end - - # Returns a new set built by merging the set and the elements of the - # given enumerable object. - # - # Set[1, 2, 3] | Set[2, 4, 5] #=> #<Set: {1, 2, 3, 4, 5}> - # Set[1, 5, 'z'] | (1..6) #=> #<Set: {1, 5, "z", 2, 3, 4, 6}> - def |(enum) - dup.merge(enum) - end - alias + | - alias union | - - # Returns a new set built by duplicating the set, removing every - # element that appears in the given enumerable object. - # - # Set[1, 3, 5] - Set[1, 5] #=> #<Set: {3}> - # Set['a', 'b', 'z'] - ['a', 'c'] #=> #<Set: {"b", "z"}> - def -(enum) - dup.subtract(enum) - end - alias difference - - - # Returns a new set containing elements common to the set and the - # given enumerable object. - # - # Set[1, 3, 5] & Set[3, 2, 1] #=> #<Set: {3, 1}> - # Set['a', 'b', 'z'] & ['a', 'b', 'c'] #=> #<Set: {"a", "b"}> - 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 - alias intersection & - - # Returns a new set containing elements exclusive between the set - # and the given enumerable object. `(set ^ enum)` is equivalent to - # `((set | enum) - (set & enum))`. - # - # Set[1, 2] ^ Set[2, 3] #=> #<Set: {3, 1}> - # Set[1, 'b', 'c'] ^ ['b', 'd'] #=> #<Set: {"d", 1, "c"}> - def ^(enum) - n = Set.new(enum) - each { |o| n.add(o) unless n.delete?(o) } - n - end - - # Returns true if two sets are equal. The equality of each couple - # of elements is defined according to Object#eql?. - # - # Set[1, 2] == Set[2, 1] #=> true - # Set[1, 3, 5] == Set[1, 5] #=> false - # Set['a', 'b', 'c'] == Set['a', 'c', 'b'] #=> true - # Set['a', 'b', 'c'] == ['a', 'c', 'b'] #=> false - 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 - - def hash # :nodoc: - @hash.hash - end - - def eql?(o) # :nodoc: - return false unless o.is_a?(Set) - @hash.eql?(o.instance_variable_get(:@hash)) - end - - # Resets the internal state after modification to existing elements - # and returns self. - # - # Elements will be reindexed and deduplicated. - def reset - if @hash.respond_to?(:rehash) - @hash.rehash # This should perform frozenness check. - else - raise FrozenError, "can't modify frozen #{self.class.name}" if frozen? - end - self - end - - # Returns true if the given object is a member of the set, - # and false otherwise. - # - # Used in case statements: - # - # require 'set' - # - # case :apple - # when Set[:potato, :carrot] - # "vegetable" - # when Set[:apple, :banana] - # "fruit" - # end - # # => "fruit" - # - # Or by itself: - # - # Set[1, 2, 3] === 2 #=> true - # Set[1, 2, 3] === 4 #=> false - # - alias === include? - - # Classifies the set by the return value of the given block and - # returns a hash of {value => set of elements} pairs. The block is - # called once for each element of the set, passing the element as - # parameter. - # - # require 'set' - # files = Set.new(Dir.glob("*.rb")) - # hash = files.classify { |f| File.mtime(f).year } - # hash #=> {2000=>#<Set: {"a.rb", "b.rb"}>, - # # 2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>, - # # 2002=>#<Set: {"f.rb"}>} - # - # Returns an enumerator if no block is given. - 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 - - # Divides the set into a set of subsets according to the commonality - # defined by the given block. - # - # If the arity of the block is 2, elements o1 and o2 are in common - # if block.call(o1, o2) is true. Otherwise, elements o1 and o2 are - # in common if block.call(o1) == block.call(o2). - # - # require 'set' - # numbers = Set[1, 3, 4, 6, 9, 10, 11] - # set = numbers.divide { |i,j| (i - j).abs == 1 } - # set #=> #<Set: {#<Set: {1}>, - # # #<Set: {11, 9, 10}>, - # # #<Set: {3, 4}>, - # # #<Set: {6}>}> - # - # Returns an enumerator if no block is given. - 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 - - # Returns a string created by converting each element of the set to a string - # See also: Array#join - def join(separator=nil) - to_a.join(separator) - end - - InspectKey = :__inspect_key__ # :nodoc: - - # Returns a string containing a human-readable representation of the - # set ("#<Set: {element1, element2, ...}>"). - 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 - - alias to_s inspect - - def pretty_print(pp) # :nodoc: - pp.group(1, sprintf('#<%s:', self.class.name), '>') { - pp.breakable - pp.group(1, '{', '}') { - pp.seplist(self) { |o| - pp.pp o - } - } - } - end - - def pretty_print_cycle(pp) # :nodoc: - pp.text sprintf('#<%s: {%s}>', self.class.name, empty? ? '' : '...') - end -end - -module Enumerable - # Makes a set from the enumerable object with given arguments. - # Needs to `require "set"` to use this method. - def to_set(klass = Set, *args, &block) - klass.new(self, *args, &block) - end unless method_defined?(:to_set) -end - -autoload :SortedSet, "#{__dir__}/set/sorted_set" |