hamster 1.0.1.pre.rc3 → 2.0.0

data/lib/hamster/mutable_hash.rb

@@ -1,16 +1,15 @@
-require "forwardable"
 require "hamster/hash"
 require "hamster/read_copy_update"
 
 module Hamster
-  def self.mutable_hash(pairs = {}, &block)
-    MutableHash.new(hash(pairs, &block))
-  end
-
+  # @api private
   class MutableHash
-    extend Forwardable
     include ReadCopyUpdate
 
+    def self.[](pairs = {})
+      MutableHash.new(Hash[pairs])
+    end
+
     def put(key, value = Undefined, &block)
       transform { |hash| hash.put(key, value, &block) }
     end
@@ -19,7 +18,7 @@ module Hamster
       put(key, value)
       value
     end
-    def_delegator :self, :store, :[]=
+    alias :[]= :store
 
     def delete(key)
       old_value = nil

data/lib/hamster/nested.rb

@@ -0,0 +1,78 @@
+require "set"
+require "hamster/hash"
+require "hamster/set"
+require "hamster/vector"
+require "hamster/sorted_set"
+require "hamster/list"
+require "hamster/deque"
+require "hamster/core_ext/struct"
+
+module Hamster
+  class << self
+
+    # Create a Hamster immutable data structure with nested Hamster data
+    # structure from a nested Ruby object `obj`.  This method recursively
+    # "walks" the Ruby object, converting Ruby `Hash` to {Hamster::Hash}, Ruby
+    # `Array` to {Hamster::Vector}, Ruby `Set` to {Hamster::Set}, and Ruby
+    # `SortedSet` to {Hamster::SortedSet}.  Other objects are left as-is.
+    #
+    # @example
+    #   h = Hamster.from({ "a" => [1, 2], "b" => "c" })
+    #   # => Hamster::Hash["a" => Hamster::Vector[1, 2], "b" => "c"]
+    #
+    # @return [Hash, Vector, Set, SortedSet, Object]
+    def from(obj)
+      case obj
+      when ::Hash
+        res = obj.map { |key, value| [from(key), from(value)] }
+        Hamster::Hash.new(res)
+      when Hamster::Hash
+        obj.map { |key, value| [from(key), from(value)] }
+      when ::Struct
+        from(obj.to_h)
+      when ::Array
+        res = obj.map { |element| from(element) }
+        Hamster::Vector.new(res)
+      when ::SortedSet
+        # This clause must go before ::Set clause, since ::SortedSet is a ::Set.
+        res = obj.map { |element| from(element) }
+        Hamster::SortedSet.new(res)
+      when ::Set
+        res = obj.map { |element| from(element) }
+        Hamster::Set.new(res)
+      when Hamster::Vector, Hamster::Set, Hamster::SortedSet
+        obj.map { |element| from(element) }
+      else
+        obj
+      end
+    end
+
+    # Create a Ruby object from Hamster data. This method recursively "walks"
+    # the Hamster object, converting {Hamster::Hash} to Ruby `Hash`,
+    # {Hamster::Vector} and {Hamster::Deque} to Ruby `Array`, {Hamster::Set}
+    # to Ruby `Set`, and {Hamster::SortedSet} to Ruby `SortedSet`.  Other
+    # objects are left as-is.
+    #
+    # @example
+    #   h = Hamster.to_ruby(Hamster.from({ "a" => [1, 2], "b" => "c" }))
+    #   # => { "a" => [1, 2], "b" => "c" }
+    #
+    # @return [::Hash, ::Array, ::Set, ::SortedSet, Object]
+    def to_ruby(obj)
+      case obj
+      when Hamster::Hash, ::Hash
+        obj.each_with_object({}) { |keyval, hash| hash[to_ruby(keyval[0])] = to_ruby(keyval[1]) }
+      when Hamster::Vector, ::Array
+        obj.each_with_object([]) { |element, arr| arr << to_ruby(element) }
+      when Hamster::Set, ::Set
+        obj.each_with_object(::Set.new) { |element, set| set << to_ruby(element) }
+      when Hamster::SortedSet, ::SortedSet
+        obj.each_with_object(::SortedSet.new) { |element, set| set << to_ruby(element) }
+      when Hamster::Deque
+        obj.to_a.tap { |arr| arr.map! { |element| to_ruby(element) }}
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/hamster/read_copy_update.rb

@@ -14,7 +14,7 @@ module Hamster
     def eql?(other)
       instance_of?(other.class) && @content.eql?(other.instance_variable_get(:@content))
     end
-    def_delegator :self, :eql?, :==
+    alias :== :eql?
 
     def_delegator :@content, :inspect
     def_delegator :@content, :to_s

data/lib/hamster/set.rb

@@ -1,17 +1,15 @@
-require "forwardable"
 require "hamster/immutable"
 require "hamster/undefined"
 require "hamster/enumerable"
+require "hamster/hash"
 require "hamster/trie"
 require "hamster/sorted_set"
+require "set"
 
 module Hamster
-  def self.set(*items)
-    items.empty? ? EmptySet : Set.new(items)
-  end
 
   # `Hamster::Set` is a collection of unordered values with no duplicates. Testing whether
-  # an object is present in the `Set` is fast. `Set` is also `Enumerable`, so you can
+  # an object is present in the `Set` can be done in constant time. `Set` is also `Enumerable`, so you can
   # iterate over the members of the set with {#each}, transform them with {#map}, filter
   # them with {#select}, and so on. Some of the `Enumerable` methods are overridden to
   # return Hamster collections.
@@ -24,15 +22,13 @@ module Hamster
   #
   # `Set`s have no natural ordering and cannot be compared using `#<=>`. However, they
   # define {#<}, {#>}, {#<=}, and {#>=} as shorthand for {#proper_subset?},
-  # {#proper_superset?}, {#subset?}, and {#superset?} (respectively).
+  # {#proper_superset?}, {#subset?}, and {#superset?} respectively.
   #
   # The basic set-theoretic operations {#union}, {#intersection}, {#difference}, and
-  # {#exclusion} work with any `Enumerable` object. They may be more efficient when used
-  # with another `Hamster::Set`, or a RubySet.
+  # {#exclusion} work with any `Enumerable` object.
   #
-  # A `Set` can be created in any of the following ways:
+  # A `Set` can be created in either of the following ways:
   #
-  #     Hamster.set('Tom', 'Dick', 'Harry')
   #     Hamster::Set.new([1, 2, 3]) # any Enumerable can be used to initialize
   #     Hamster::Set['A', 'B', 'C', 'D']
   #
@@ -43,8 +39,7 @@ module Hamster
   # actually return a new set and leave the existing one unchanged.
   #
   # @example
-  #   require 'hamster/set'
-  #   set1 = Hamster.set(1, 2)  # => Hamster::Set[1, 2]
+  #   set1 = Hamster::Set[1, 2] # => Hamster::Set[1, 2]
   #   set2 = Hamster::Set[1, 2] # => Hamster::Set[1, 2]
   #   set1 == set2              # => true
   #   set3 = set1.add("foo")    # => Hamster::Set[1, 2, "foo"]
@@ -53,7 +48,6 @@ module Hamster
   #   set1.subset?(set3)        # => true
   #
   class Set
-    extend Forwardable
     include Immutable
     include Enumerable
 
@@ -61,7 +55,7 @@ module Hamster
       # Create a new `Set` populated with the given items.
       # @return [Set]
       def [](*items)
-        new(items)
+        items.empty? ? empty : new(items)
       end
 
       # Return an empty `Set`. If used on a subclass, returns an empty instance
@@ -92,30 +86,35 @@ module Hamster
     def empty?
       @trie.empty?
     end
-    def_delegator :self, :empty?, :null?
 
     # Return the number of items in this `Set`.
     # @return [Integer]
     def size
       @trie.size
     end
-    def_delegator :self, :size, :length
+    alias :length :size
 
     # Return a new `Set` with `item` added. If `item` is already in the set,
     # return `self`.
     #
+    # @example
+    #   Hamster::Set[1, 2, 3].add(4) # => Hamster::Set[1, 2, 4, 3]
+    #   Hamster::Set[1, 2, 3].add(2) # => Hamster::Set[1, 2, 3]
+    #
     # @param item [Object] The object to add
     # @return [Set]
     def add(item)
       include?(item) ? self : self.class.alloc(@trie.put(item, nil))
     end
-    def_delegator :self, :add, :<<
-    def_delegator :self, :add, :conj
-    def_delegator :self, :add, :conjoin
+    alias :<< :add
 
     # If `item` is not a member of this `Set`, return a new `Set` with `item` added.
     # Otherwise, return `false`.
     #
+    # @example
+    #   Hamster::Set[1, 2, 3].add?(4) # => Hamster::Set[1, 2, 4, 3]
+    #   Hamster::Set[1, 2, 3].add?(2) # => false
+    #
     # @param item [Object] The object to add
     # @return [Set, false]
     def add?(item)
@@ -125,22 +124,24 @@ module Hamster
     # Return a new `Set` with `item` removed. If `item` is not a member of the set,
     # return `self`.
     #
+    # @example
+    #   Hamster::Set[1, 2, 3].delete(1)  # => Hamster::Set[2, 3]
+    #   Hamster::Set[1, 2, 3].delete(99) # => Hamster::Set[1, 2, 3]
+    #
     # @param item [Object] The object to remove
     # @return [Set]
     def delete(item)
       trie = @trie.delete(item)
-      if trie.equal?(@trie)
-        self
-      elsif trie.empty?
-        self.class.empty
-      else
-        self.class.alloc(trie)
-      end
+      new_trie(trie)
     end
 
     # If `item` is a member of this `Set`, return a new `Set` with `item` removed.
     # Otherwise, return `false`.
     #
+    # @example
+    #   Hamster::Set[1, 2, 3].delete?(1)  # => Hamster::Set[2, 3]
+    #   Hamster::Set[1, 2, 3].delete?(99) # => false
+    #
     # @param item [Object] The object to remove
     # @return [Set, false]
     def delete?(item)
@@ -148,9 +149,18 @@ module Hamster
     end
 
     # Call the block once for each item in this `Set`. No specific iteration order
-    # is guaranteed (but the order will be stable for any particular `Set`.)
+    # is guaranteed, but the order will be stable for any particular `Set`. If
+    # no block is given, an `Enumerator` is returned instead.
     #
-    # @return [self]
+    # @example
+    #   Hamster::Set["Dog", "Elephant", "Lion"].each { |e| puts e }
+    #   Elephant
+    #   Dog
+    #   Lion
+    #   # => Hamster::Set["Dog", "Elephant", "Lion"]
+    #
+    # @yield [item] Once for each item.
+    # @return [self, Enumerator]
     def each
       return to_enum if not block_given?
       @trie.each { |key, _| yield(key) }
@@ -158,8 +168,17 @@ module Hamster
     end
 
     # Call the block once for each item in this `Set`. Iteration order will be
-    # the opposite of {#each}.
+    # the opposite of {#each}. If no block is given, an `Enumerator` is
+    # returned instead.
     #
+    # @example
+    #   Hamster::Set["Dog", "Elephant", "Lion"].reverse_each { |e| puts e }
+    #   Lion
+    #   Dog
+    #   Elephant
+    #   # => Hamster::Set["Dog", "Elephant", "Lion"]
+    #
+    # @yield [item] Once for each item.
     # @return [self]
     def reverse_each
       return enum_for(:reverse_each) if not block_given?
@@ -169,65 +188,93 @@ module Hamster
 
     # Return a new `Set` with all the items for which the block returns true.
     #
+    # @example
+    #   Hamster::Set["Elephant", "Dog", "Lion"].select { |e| e.size >= 4 }
+    #   # => Hamster::Set["Elephant", "Lion"]
+    # @yield [item] Once for each item.
     # @return [Set]
-    def filter
-      return enum_for(:filter) unless block_given?
-      trie = @trie.filter { |entry| yield(entry[0]) }
-      return self.class.empty if trie.empty?
-      trie.equal?(@trie) ? self : self.class.alloc(trie)
+    def select
+      return enum_for(:select) unless block_given?
+      trie = @trie.select { |key, _| yield(key) }
+      new_trie(trie)
     end
+    alias :find_all :select
+    alias :keep_if  :select
 
-    def_delegator :self, :reduce, :foldr # set is not ordered, so foldr is same as reduce
-
-    # Call the block once for each item in this `Set`.
-    # All the values returned from the block will be gathered into a new `Set`.
+    # Call the block once for each item in this `Set`. All the values returned
+    # from the block will be gathered into a new `Set`. If no block is given,
+    # an `Enumerator` is returned instead.
     #
+    # @example
+    #   Hamster::Set["Cat", "Elephant", "Dog", "Lion"].map { |e| e.size }
+    #   # => Hamster::Set[8, 4, 3]
+    #
+    # @yield [item] Once for each item.
     # @return [Set]
     def map
       return enum_for(:map) if not block_given?
       return self if empty?
       self.class.new(super)
     end
-    def_delegator :self, :map, :collect
+    alias :collect :map
 
     # Return `true` if the given item is present in this `Set`. More precisely,
     # return `true` if an object with the same `#hash` code, and which is also `#eql?`
     # to the given object is present.
     #
+    # @example
+    #   Hamster::Set["A", "B", "C"].include?("B") # => true
+    #   Hamster::Set["A", "B", "C"].include?("Z") # => false
+    #
     # @param object [Object] The object to check for
     # @return [Boolean]
     def include?(object)
       @trie.key?(object)
     end
-    def_delegator :self, :include?, :member?
+    alias :member? :include?
 
     # Return a member of this `Set`. The member chosen will be the first one which
     # would be yielded by {#each}. If the set is empty, return `nil`.
     #
+    # @example
+    #   Hamster::Set["A", "B", "C"].first # => "C"
+    #
     # @return [Object]
     def first
       (entry = @trie.at(0)) && entry[0]
     end
-    def_delegator :self, :first, :head
 
     # Return a {SortedSet} which contains the same items as this `Set`, ordered by
-    # the given comparator block. The comparator block should take 2 parameters and
-    # return 0, 1, or -1 depending on whether the first parameter is equal, greater than,
-    # or less than the second.
+    # the given comparator block.
     #
-    # @yield [a, b] A pair of items to be compared
-    # @yieldreturn [Integer]
+    # @example
+    #   Hamster::Set["Elephant", "Dog", "Lion"].sort
+    #   # => Hamster::SortedSet["Dog", "Elephant", "Lion"]
+    #   Hamster::Set["Elephant", "Dog", "Lion"].sort { |a,b| a.size <=> b.size }
+    #   # => Hamster::SortedSet["Dog", "Lion", "Elephant"]
+    #
+    # @yield [a, b] Any number of times with different pairs of elements.
+    # @yieldreturn [Integer] Negative if the first element should be sorted
+    #                        lower, positive if the latter element, or 0 if
+    #                        equal.
     # @return [SortedSet]
     def sort(&comparator)
       SortedSet.new(self.to_a, &comparator)
     end
 
-    # Return a {SortedSet} which contains the same items as this `Set`, ordered by
-    # mapping each item through the provided block to obtain sort keys, and then
-    # sorting the keys.
+    # Return a {SortedSet} which contains the same items as this `Set`, ordered
+    # by mapping each item through the provided block to obtain sort keys, and
+    # then sorting the keys.
     #
-    # @yield [item] The item to obtain a sort key for
-    # @yieldreturn [Object]
+    # @example
+    #   Hamster::Set["Elephant", "Dog", "Lion"].sort_by { |e| e.size }
+    #   # => Hamster::SortedSet["Dog", "Lion", "Elephant"]
+    #
+    # @yield [item] Once for each item to create the set, and then potentially
+    #               again depending on what operations are performed on the
+    #               returned {SortedSet}. As such, it is recommended that the
+    #               block be a pure function.
+    # @yieldreturn [Object] sort key for the item
     # @return [SortedSet]
     def sort_by(&mapper)
       SortedSet.new(self.to_a, &mapper)
@@ -242,22 +289,29 @@ module Hamster
     # @param other [Enumerable] The collection to merge with
     # @return [Set]
     def union(other)
-      if other.is_a?(Hamster::Set) && other.size > size
-        small_set = self
-        large_set_trie = other.instance_variable_get(:@trie)
+      if other.is_a?(Hamster::Set)
+        if other.size > size
+          small_set_pairs = @trie
+          large_set_trie = other.instance_variable_get(:@trie)
+        else
+          small_set_pairs = other.instance_variable_get(:@trie)
+          large_set_trie = @trie
+        end
       else
-        small_set = other
+        if other.respond_to?(:lazy)
+          small_set_pairs = other.lazy.map { |e| [e, nil] }
+        else
+          small_set_pairs = other.map { |e| [e, nil] }
+        end
         large_set_trie = @trie
       end
-      trie = small_set.reduce(large_set_trie) do |a, element|
-        next a if a.key?(element)
-        a.put(element, nil)
-      end
-      trie.equal?(@trie) ? self : self.class.alloc(trie)
+
+      trie = large_set_trie.bulk_put(small_set_pairs)
+      new_trie(trie)
     end
-    def_delegator :self, :union, :|
-    def_delegator :self, :union, :+
-    def_delegator :self, :union, :merge
+    alias :| :union
+    alias :+ :union
+    alias :merge :union
 
     # Return a new `Set` which contains all the items which are members of both
     # this `Set` and `other`. `other` can be any `Enumerable` object.
@@ -268,15 +322,19 @@ module Hamster
     # @param other [Enumerable] The collection to intersect with
     # @return [Set]
     def intersection(other)
-      if (other.size < @trie.size) && other.is_a?(Hamster::Set)
-        trie = other.instance_variable_get(:@trie).filter { |key, _| include?(key) }
+      if other.size < @trie.size
+        if other.is_a?(Hamster::Set)
+          trie = other.instance_variable_get(:@trie).select { |key, _| include?(key) }
+        else
+          trie = Trie.new(0)
+          other.each { |obj| trie.put!(obj, nil) if include?(obj) }
+        end
       else
-        trie = @trie.filter { |key, _| other.include?(key) }
+        trie = @trie.select { |key, _| other.include?(key) }
       end
-      trie.equal?(@trie) ? self : self.class.alloc(trie)
+      new_trie(trie)
     end
-    def_delegator :self, :intersection, :intersect
-    def_delegator :self, :intersection, :&
+    alias :& :intersection
 
     # Return a new `Set` with all the items in `other` removed. `other` can be
     # any `Enumerable` object.
@@ -288,15 +346,14 @@ module Hamster
     # @return [Set]
     def difference(other)
       trie = if (@trie.size <= other.size) && (other.is_a?(Hamster::Set) || (defined?(::Set) && other.is_a?(::Set)))
-        @trie.filter { |key, _| !other.include?(key) }
+        @trie.select { |key, _| !other.include?(key) }
       else
-        other.reduce(@trie) { |trie, item| trie.delete(item) }
+        @trie.bulk_delete(other)
       end
-      trie.empty? ? self.class.empty : self.class.alloc(trie)
+      new_trie(trie)
     end
-    def_delegator :self, :difference, :diff
-    def_delegator :self, :difference, :subtract
-    def_delegator :self, :difference, :-
+    alias :subtract :difference
+    alias :- :difference
 
     # Return a new `Set` which contains all the items which are members of this
     # `Set` or of `other`, but not both. `other` can be any `Enumerable` object.
@@ -309,20 +366,39 @@ module Hamster
     def exclusion(other)
       ((self | other) - (self & other))
     end
-    def_delegator :self, :exclusion, :^
+    alias :^ :exclusion
 
     # Return `true` if all items in this `Set` are also in `other`.
     #
+    # @example
+    #   Hamster::Set[2, 3].subset?(Hamster::Set[1, 2, 3]) # => true
+    #
     # @param other [Set]
     # @return [Boolean]
     def subset?(other)
       return false if other.size < size
+
+      # This method has the potential to be very slow if 'other' is a large Array, so to avoid that,
+      #   we convert those Arrays to Sets before checking presence of items
+      # Time to convert Array -> Set is linear in array.size
+      # Time to check for presence of all items in an Array is proportional to set.size * array.size
+      # Note that both sides of that equation have array.size -- hence those terms cancel out,
+      #   and the break-even point is solely dependent on the size of this collection
+      # After doing some benchmarking to estimate the constants, it appears break-even is at ~190 items
+      # We also check other.size, to avoid the more expensive #is_a? checks in cases where it doesn't matter
+      #
+      if other.size >= 150 && @trie.size >= 190 && !(other.is_a?(Hamster::Set) || other.is_a?(::Set))
+        other = ::Set.new(other)
+      end
       all? { |item| other.include?(item) }
     end
     alias :<= :subset?
 
     # Return `true` if all items in `other` are also in this `Set`.
     #
+    # @example
+    #   Hamster::Set[1, 2, 3].superset?(Hamster::Set[2, 3]) # => true
+    #
     # @param other [Set]
     # @return [Boolean]
     def superset?(other)
@@ -333,10 +409,18 @@ module Hamster
     # Returns `true` if `other` contains all the items in this `Set`, plus at least
     # one item which is not in this set.
     #
+    # @example
+    #   Hamster::Set[2, 3].proper_subset?(Hamster::Set[1, 2, 3])    # => true
+    #   Hamster::Set[1, 2, 3].proper_subset?(Hamster::Set[1, 2, 3]) # => false
+    #
     # @param other [Set]
     # @return [Boolean]
     def proper_subset?(other)
       return false if other.size <= size
+      # See comments above
+      if other.size >= 150 && @trie.size >= 190 && !(other.is_a?(Hamster::Set) || other.is_a?(::Set))
+        other = ::Set.new(other)
+      end
       all? { |item| other.include?(item) }
     end
     alias :< :proper_subset?
@@ -344,6 +428,10 @@ module Hamster
     # Returns `true` if this `Set` contains all the items in `other`, plus at least
     # one item which is not in `other`.
     #
+    # @example
+    #   Hamster::Set[1, 2, 3].proper_superset?(Hamster::Set[2, 3])    # => true
+    #   Hamster::Set[1, 2, 3].proper_superset?(Hamster::Set[1, 2, 3]) # => false
+    #
     # @param other [Set]
     # @return [Boolean]
     def proper_superset?(other)
@@ -353,19 +441,29 @@ module Hamster
 
     # Return `true` if this `Set` and `other` do not share any items.
     #
+    # @example
+    #   Hamster::Set[1, 2].disjoint?(Hamster::Set[8, 9]) # => true
+    #
     # @param other [Set]
     # @return [Boolean]
     def disjoint?(other)
-      if size < other.size
-        each { |item| return false if other.include?(item) }
-      else
+      if other.size <= size
         other.each { |item| return false if include?(item) }
+      else
+        # See comment on #subset?
+        if other.size >= 150 && @trie.size >= 190 && !(other.is_a?(Hamster::Set) || other.is_a?(::Set))
+          other = ::Set.new(other)
+        end
+        each { |item| return false if other.include?(item) }
       end
       true
     end
 
     # Return `true` if this `Set` and `other` have at least one item in common.
     #
+    # @example
+    #   Hamster::Set[1, 2].intersect?(Hamster::Set[2, 3]) # => true
+    #
     # @param other [Set]
     # @return [Boolean]
     def intersect?(other)
@@ -387,11 +485,14 @@ module Hamster
       end
     end
 
-    def_delegator :self, :group_by, :group
-    def_delegator :self, :group_by, :classify
+    alias :group :group_by
+    alias :classify :group_by
 
     # Return a randomly chosen item from this `Set`. If the set is empty, return `nil`.
     #
+    # @example
+    #   Hamster::Set[1, 2, 3, 4, 5].sample # => 3
+    #
     # @return [Object]
     def sample
       empty? ? nil : @trie.at(rand(size))[0]
@@ -400,7 +501,7 @@ module Hamster
     # Return an empty `Set` instance, of the same class as this one. Useful if you
     # have multiple subclasses of `Set` and want to treat them polymorphically.
     #
-    # @return [Hash]
+    # @return [Set]
     def clear
       self.class.empty
     end
@@ -419,7 +520,7 @@ module Hamster
       end
       true
     end
-    def_delegator :self, :eql?, :==
+    alias :== :eql?
 
     # See `Object#hash`.
     # @return [Integer]
@@ -430,10 +531,6 @@ module Hamster
     undef :"<=>" # Sets are not ordered, so Enumerable#<=> will give a meaningless result
     undef :each_index # Set members cannot be accessed by 'index', so #each_index is not meaningful
 
-    def_delegator :self, :dup, :uniq
-    def_delegator :self, :dup, :nub
-    def_delegator :self, :dup, :remove_duplicates
-
     # Return `self`.
     #
     # @return [self]
@@ -456,11 +553,24 @@ module Hamster
         trie.put(key_value.first, nil)
       end
     end
+
+    private
+
+    def new_trie(trie)
+      if trie.empty?
+        self.class.empty
+      elsif trie.equal?(@trie)
+        self
+      else
+        self.class.alloc(trie)
+      end
+    end
   end
 
-  # The canonical empty `Set`. Returned by `Hamster.set` and `Set[]` when
+  # The canonical empty `Set`. Returned by `Set[]` when
   # invoked with no arguments; also returned by `Set.empty`. Prefer using this
   # one rather than creating many empty sets using `Set.new`.
   #
+  # @private
   EmptySet = Hamster::Set.empty
 end