hamster 1.0.1.pre.rc3 → 2.0.0

data/lib/hamster/trie.rb

@@ -29,7 +29,15 @@ module Hamster
 
     # Calls <tt>block</tt> once for each entry in the trie, passing the key-value pair as parameters.
     def each(&block)
-      @entries.each { |entry| yield(entry) if entry }
+      # TODO: Using block.call here is slower than using yield by 5-10%, but
+      # the latter segfaults on ruby 2.2 and above. Once that is fixed and
+      # broken versions are sufficiently old, we should revert back to yield
+      # with a warning that the broken versions are unsupported.
+      #
+      # For more context:
+      # * https://bugs.ruby-lang.org/issues/11451
+      # * https://github.com/hamstergem/hamster/issues/189
+      @entries.each { |entry| block.call(entry) if entry }
       @children.each do |child|
         child.each(&block) if child
       end
@@ -49,11 +57,15 @@ module Hamster
       memo
     end
 
-    def filter
-      reduce(self) { |trie, entry| yield(entry) ? trie : trie.delete(entry[0]) }
+    def select
+      keys_to_delete = []
+      each { |entry| keys_to_delete << entry[0] unless yield(entry) }
+      bulk_delete(keys_to_delete)
     end
 
-    # Returns a copy of <tt>self</tt> with the given value associated with the key.
+    # @return [Trie] A copy of `self` with the given value associated with the
+    #   key (or `self` if no modification was needed because an identical
+    #   key-value pair wes already stored
     def put(key, value)
       index = index_for(key)
       entry = @entries[index]
@@ -64,22 +76,81 @@ module Hamster
         entries[index] = [key, value].freeze
         Trie.new(@significant_bits, @size + 1, entries, @children)
       elsif entry[0].eql?(key)
-        entries = @entries.dup
-        key = key.dup.freeze if key.is_a?(String) && !key.frozen?
-        entries[index] = [key, value].freeze
-        Trie.new(@significant_bits, @size, entries, @children)
+        if entry[1].equal?(value)
+          self
+        else
+          entries = @entries.dup
+          key = key.dup.freeze if key.is_a?(String) && !key.frozen?
+          entries[index] = [key, value].freeze
+          Trie.new(@significant_bits, @size, entries, @children)
+        end
       else
-        children = @children.dup
-        child = children[index]
-        child_size = child ? child.size : 0
+        child = @children[index]
         if child
-          children[index] = child.put(key, value)
+          new_child = child.put(key, value)
+          if new_child.equal?(child)
+            self
+          else
+            children = @children.dup
+            children[index] = new_child
+            new_self_size = @size + (new_child.size - child.size)
+            Trie.new(@significant_bits, new_self_size, @entries, children)
+          end
         else
+          children = @children.dup
           children[index] = Trie.new(@significant_bits + 5).put!(key, value)
+          Trie.new(@significant_bits, @size + 1, @entries, children)
         end
-        new_child_size = children[index].size
-        new_self_size = @size + (new_child_size - child_size)
-        Trie.new(@significant_bits, new_self_size, @entries, children)
+      end
+    end
+
+    # Put multiple elements into a Trie.  This is more efficient than several
+    # calls to `#put`.
+    #
+    # @param key_value_pairs Enumerable of pairs (`[key, value]`)
+    # @return [Trie] A copy of `self` after associated the given keys and
+    #   values (or `self` if no modifications where needed).
+    def bulk_put(key_value_pairs)
+      new_entries = nil
+      new_children = nil
+      new_size = @size
+
+      key_value_pairs.each do |key, value|
+        index = index_for(key)
+        entry = (new_entries || @entries)[index]
+
+        if !entry
+          new_entries ||= @entries.dup
+          key = key.dup.freeze if key.is_a?(String) && !key.frozen?
+          new_entries[index] = [key, value].freeze
+          new_size += 1
+        elsif entry[0].eql?(key)
+          if !entry[1].equal?(value)
+            new_entries ||= @entries.dup
+            key = key.dup.freeze if key.is_a?(String) && !key.frozen?
+            new_entries[index] = [key, value].freeze
+          end
+        else
+          child = (new_children || @children)[index]
+          if child
+            new_child = child.put(key, value)
+            if !new_child.equal?(child)
+              new_children ||= @children.dup
+              new_children[index] = new_child
+              new_size += new_child.size - child.size
+            end
+          else
+            new_children ||= @children.dup
+            new_children[index] = Trie.new(@significant_bits + 5).put!(key, value)
+            new_size += 1
+          end
+        end
+      end
+
+      if new_entries || new_children
+        Trie.new(@significant_bits, new_size, new_entries || @entries, new_children || @children)
+      else
+        self
       end
     end
 
@@ -125,6 +196,54 @@ module Hamster
       find_and_delete(key) || Trie.new(@significant_bits)
     end
 
+    # Delete multiple elements from a Trie.  This is more efficient than
+    # several calls to `#delete`.
+    #
+    # @param keys [Enumerable] The keys to delete
+    # @return [Trie]
+    def bulk_delete(keys)
+      new_entries = nil
+      new_children = nil
+      new_size = @size
+
+      keys.each do |key|
+        index = index_for(key)
+        entry = (new_entries || @entries)[index]
+        if !entry
+          next
+        elsif entry[0].eql?(key)
+          new_entries ||= @entries.dup
+          child = (new_children || @children)[index]
+          if child
+            # Bring up the first entry from the child into entries
+            new_children ||= @children.dup
+            new_children[index] = child.delete_at do |entry|
+              new_entries[index] = entry
+            end
+          else
+            new_entries[index] = nil
+          end
+          new_size -= 1
+        else
+          child = (new_children || @children)[index]
+          if child
+            copy = child.find_and_delete(key)
+            unless copy.equal?(child)
+              new_children ||= @children.dup
+              new_children[index] = copy
+              new_size -= (child.size - copy_size(copy))
+            end
+          end
+        end
+      end
+
+      if new_entries || new_children
+        Trie.new(@significant_bits, new_size, new_entries || @entries, new_children || @children)
+      else
+        self
+      end
+    end
+
     def include?(key, value)
       entry = get(key)
       entry && value.eql?(entry[1])

data/lib/hamster/vector.rb

@@ -1,31 +1,27 @@
-require "forwardable"
 require "hamster/immutable"
 require "hamster/enumerable"
+require "hamster/hash"
+require "hamster/associable"
 
 module Hamster
-  def self.vector(*items)
-    items.empty? ? EmptyVector : Vector.new(items.freeze)
-  end
-
-  # A `Vector` is an ordered, integer-indexed collection of objects. Like `Array`,
-  # `Vector` indexing starts at 0. Also like `Array`, negative indexes count back
-  # from the end of the `Vector`.
+  # A `Vector` is an ordered, integer-indexed collection of objects. Like
+  # Ruby's `Array`, `Vector` indexing starts at zero and negative indexes count
+  # back from the end.
   #
-  # `Vector`'s interface is modeled after that of `Array`, minus all the methods
-  # which do destructive updates. Some methods which modify `Array`s destructively
-  # (like {#insert} or {#delete_at}) are included, but they return new `Vectors`
-  # and leave the existing one unchanged.
+  # `Vector` has a similar interface to `Array`. The main difference is methods
+  # that would destructively update an `Array` (such as {#insert} or
+  # {#delete_at}) instead return new `Vectors` and leave the existing one
+  # unchanged.
   #
-  # = Creating New Vectors
+  # ### Creating New Vectors
   #
-  #     Hamster.vector('a', 'b', 'c')
   #     Hamster::Vector.new([:first, :second, :third])
   #     Hamster::Vector[1, 2, 3, 4, 5]
   #
-  # = Retrieving Items from Vectors
+  # ### Retrieving Items from Vectors
+  #
+  #     vector = Hamster::Vector[1, 2, 3, 4, 5]
   #
-  #     require 'hamster/vector'
-  #     vector = Hamster.vector(1, 2, 3, 4, 5)
   #     vector[0]      # => 1
   #     vector[-1]     # => 5
   #     vector[0,3]    # => Hamster::Vector[1, 2, 3]
@@ -33,21 +29,17 @@ module Hamster
   #     vector.first   # => 1
   #     vector.last    # => 5
   #
-  # = Creating Modified Vectors
+  # ### Creating Modified Vectors
   #
   #     vector.add(6)            # => Hamster::Vector[1, 2, 3, 4, 5, 6]
   #     vector.insert(1, :a, :b) # => Hamster::Vector[1, :a, :b, 2, 3, 4, 5]
   #     vector.delete_at(2)      # => Hamster::Vector[1, 2, 4, 5]
   #     vector + [6, 7]          # => Hamster::Vector[1, 2, 3, 4, 5, 6, 7]
   #
-  # Other `Array`-like methods like {#select}, {#map}, {#shuffle}, {#uniq}, {#reverse},
-  # {#rotate}, {#flatten}, {#sort}, {#sort_by}, {#take}, {#drop}, {#take_while},
-  # {#drop_while}, {#fill}, {#product}, and {#transpose} are also supported.
-  #
   class Vector
-    extend Forwardable
     include Immutable
     include Enumerable
+    include Associable
 
     # @private
     BLOCK_SIZE = 32
@@ -59,7 +51,7 @@ module Hamster
     # Return the number of items in this `Vector`
     # @return [Integer]
     attr_reader :size
-    def_delegator :self, :size, :length
+    alias :length :size
 
     class << self
       # Create a new `Vector` populated with the given items.
@@ -111,18 +103,22 @@ module Hamster
     def empty?
       @size == 0
     end
-    def_delegator :self, :empty?, :null?
 
     # Return the first item in the `Vector`. If the vector is empty, return `nil`.
     #
+    # @example
+    #   Hamster::Vector["A", "B", "C"].first  # => "A"
+    #
     # @return [Object]
     def first
       get(0)
     end
-    def_delegator :self, :first, :head
 
     # Return the last item in the `Vector`. If the vector is empty, return `nil`.
     #
+    # @example
+    #   Hamster::Vector["A", "B", "C"].last  # => "C"
+    #
     # @return [Object]
     def last
       get(-1)
@@ -130,33 +126,88 @@ module Hamster
 
     # Return a new `Vector` with `item` added after the last occupied position.
     #
+    # @example
+    #   Hamster::Vector[1, 2].add(99)  # => Hamster::Vector[1, 2, 99]
+    #
     # @param item [Object] The object to insert at the end of the vector
     # @return [Vector]
     def add(item)
       update_root(@size, item)
     end
-    def_delegator :self, :add, :<<
-    def_delegator :self, :add, :conj
-    def_delegator :self, :add, :conjoin
-    def_delegator :self, :add, :push
+    alias :<< :add
+    alias :push :add
 
-    # Return a new `Vector` with the item at `index` replaced by `item`. If the
-    # `item` argument is missing, but an optional code block is provided, it will
-    # be passed the existing item and what the block returns will replace it.
+    # Return a new `Vector` with a new value at the given `index`. If `index`
+    # is greater than the length of the vector, the returned vector will be
+    # padded with `nil`s to the correct size.
+    #
+    # @overload put(index, item)
+    #   Return a new `Vector` with the item at `index` replaced by `item`.
     #
-    # @param index [Integer] The index to update
-    # @param item [Object] The object to insert into that position
+    #   @param item [Object] The object to insert into that position
+    #   @example
+    #     Hamster::Vector[1, 2, 3, 4].put(2, 99)
+    #     # => Hamster::Vector[1, 2, 99, 4]
+    #     Hamster::Vector[1, 2, 3, 4].put(-1, 99)
+    #     # => Hamster::Vector[1, 2, 3, 99]
+    #     Hamster::Vector[].put(2, 99)
+    #     # => Hamster::Vector[nil, nil, 99]
+    #
+    # @overload put(index)
+    #   Return a new `Vector` with the item at `index` replaced by the return
+    #   value of the block.
+    #
+    #   @yield (existing) Once with the existing value at the given `index`.
+    #   @example
+    #     Hamster::Vector[1, 2, 3, 4].put(2) { |v| v * 10 }
+    #     # => Hamster::Vector[1, 2, 30, 4]
+    #
+    # @param index [Integer] The index to update. May be negative.
     # @return [Vector]
-    def set(index, item = yield(get(index)))
-      raise IndexError if @size == 0
+    def put(index, item = yield(get(index)))
+      raise IndexError, "index #{index} outside of vector bounds" if index < -@size
       index += @size if index < 0
-      raise IndexError if index > @size || index < 0
-      update_root(index, item)
+      if index > @size
+        suffix = Array.new(index - @size, nil)
+        suffix << item
+        replace_suffix(@size, suffix)
+      else
+        update_root(index, item)
+      end
     end
+    alias :set :put
+
+    # Return a new `Vector` with a deeply nested value modified to the result
+    # of the given code block.  When traversing the nested `Vector`s and
+    # `Hash`es, non-existing keys are created with empty `Hash` values.
+    #
+    # The code block receives the existing value of the deeply nested key (or
+    # `nil` if it doesn't exist). This is useful for "transforming" the value
+    # associated with a certain key.
+    #
+    # Note that the original `Vector` and sub-`Vector`s and sub-`Hash`es are
+    # left unmodified; new data structure copies are created along the path
+    # wherever needed.
+    #
+    # @example
+    #   v = Hamster::Vector[123, 456, 789, Hamster::Hash["a" => Hamster::Vector[5, 6, 7]]]
+    #   v.update_in(3, "a", 1) { |value| value + 9 }
+    #   # => Hamster::Vector[123, 456, 789, Hamster::Hash["a" => Hamster::Vector[5, 15, 7]]]
+    #
+    # @param key_path [Object(s)] List of keys which form the path to the key to be modified
+    # @yield [value] The previously stored value
+    # @yieldreturn [Object] The new value to store
+    # @return [Vector]
 
     # Retrieve the item at `index`. If there is none (either the provided index
     # is too high or too low), return `nil`.
     #
+    # @example
+    #   v = Hamster::Vector["A", "B", "C", "D"]
+    #   v.get(2)   # => "C"
+    #   v.get(-1)  # => "D"
+    #   v.get(4)   # => nil
+    #
     # @param index [Integer] The index to retrieve
     # @return [Object]
     def get(index)
@@ -165,26 +216,45 @@ module Hamster
       return nil if index >= @size || index < 0
       leaf_node_for(@root, @levels * BITS_PER_LEVEL, index)[index & INDEX_MASK]
     end
-    def_delegator :self, :get, :at
+    alias :at :get
 
-    # Retrieve the value at `index`, or use the provided default value or block,
-    # or otherwise raise an `IndexError`.
+    # Retrieve the value at `index` with optional default.
     #
     # @overload fetch(index)
-    #   Retrieve the value at the given index, or raise an `IndexError` if it is
-    #   not found.
+    #   Retrieve the value at the given index, or raise an `IndexError` if not
+    #   found.
+    #
     #   @param index [Integer] The index to look up
+    #   @raise [IndexError] if index does not exist
+    #   @example
+    #     v = Hamster::Vector["A", "B", "C", "D"]
+    #     v.fetch(2)       # => "C"
+    #     v.fetch(-1)      # => "D"
+    #     v.fetch(4)       # => IndexError: index 4 outside of vector bounds
+    #
     # @overload fetch(index) { |index| ... }
-    #   Retrieve the value at the given index, or call the optional
-    #   code block (with the non-existent index) and get its return value.
-    #   @yield [index] The index which does not exist
-    #   @yieldreturn [Object] Object to return instead
+    #   Retrieve the value at the given index, or return the result of yielding
+    #   the block if not found.
+    #
+    #   @yield Once if the index is not found.
+    #   @yieldparam [Integer] index The index which does not exist
+    #   @yieldreturn [Object] Default value to return
     #   @param index [Integer] The index to look up
+    #   @example
+    #     v = Hamster::Vector["A", "B", "C", "D"]
+    #     v.fetch(2) { |i| i * i }   # => "C"
+    #     v.fetch(4) { |i| i * i }   # => 16
+    #
     # @overload fetch(index, default)
-    #   Retrieve the value at the given index, or else return the provided
-    #   `default` value.
+    #   Retrieve the value at the given index, or return the provided `default`
+    #   value if not found.
+    #
     #   @param index [Integer] The index to look up
     #   @param default [Object] Object to return if the key is not found
+    #   @example
+    #     v = Hamster::Vector["A", "B", "C", "D"]
+    #     v.fetch(2, "Z")  # => "C"
+    #     v.fetch(4, "Z")  # => "Z"
     #
     # @return [Object]
     def fetch(index, default = (missing_default = true))
@@ -199,22 +269,47 @@ module Hamster
       end
     end
 
-    # Element reference. Return the item at a specific index, or a specified,
-    # contiguous range of items (as a new `Vector`).
+    # Return specific objects from the `Vector`. All overloads return `nil` if
+    # the starting index is out of range.
+    #
+    # @overload vector.slice(index)
+    #   Returns a single object at the given `index`. If `index` is negative,
+    #   count backwards from the end.
+    #
+    #   @param index [Integer] The index to retrieve. May be negative.
+    #   @return [Object]
+    #   @example
+    #     v = Hamster::Vector["A", "B", "C", "D", "E", "F"]
+    #     v[2]  # => "C"
+    #     v[-1] # => "F"
+    #     v[6]  # => nil
+    #
+    # @overload vector.slice(index, length)
+    #   Return a subvector starting at `index` and continuing for `length`
+    #   elements or until the end of the `Vector`, whichever occurs first.
     #
-    # @overload vector[index]
-    #   Return the item at `index`.
-    #   @param index [Integer] The index to retrieve.
-    # @overload vector[start, length]
-    #   Return a subvector starting at index `start` and continuing for `length` elements.
-    #   @param start [Integer] The index to start retrieving items from.
+    #   @param start [Integer] The index to start retrieving items from. May be
+    #                          negative.
     #   @param length [Integer] The number of items to retrieve.
-    # @overload vector[range]
-    #   Return a subvector specified by the given `range` of indices.
-    #   @param range [Range] The range of indices to retrieve.
+    #   @return [Vector]
+    #   @example
+    #     v = Hamster::Vector["A", "B", "C", "D", "E", "F"]
+    #     v[2, 3]  # => Hamster::Vector["C", "D", "E"]
+    #     v[-2, 3] # => Hamster::Vector["E", "F"]
+    #     v[20, 1] # => nil
     #
-    # @return [Object]
-    def [](arg, length = (missing_length = true))
+    # @overload vector.slice(index..end)
+    #   Return a subvector starting at `index` and continuing to index
+    #   `end` or the end of the `Vector`, whichever occurs first.
+    #
+    #   @param range [Range] The range of indices to retrieve.
+    #   @return [Vector]
+    #   @example
+    #     v = Hamster::Vector["A", "B", "C", "D", "E", "F"]
+    #     v[2..3]    # => Hamster::Vector["C", "D"]
+    #     v[-2..100] # => Hamster::Vector["E", "F"]
+    #     v[20..21]  # => nil
+    def slice(arg, length = (missing_length = true))
       if missing_length
         if arg.is_a?(Range)
           from, to = arg.begin, arg.end
@@ -232,13 +327,22 @@ module Hamster
         subsequence(arg, length)
       end
     end
-    def_delegator :self, :[], :slice
+    alias :[] :slice
 
-    # Return a new `Vector` with the given values inserted before the element at `index`.
+    # Return a new `Vector` with the given values inserted before the element
+    # at `index`. If `index` is greater than the current length, `nil` values
+    # are added to pad the `Vector` to the required size.
+    #
+    # @example
+    #   Hamster::Vector["A", "B", "C", "D"].insert(2, "X", "Y", "Z")
+    #   # => Hamster::Vector["A", "B", "X", "Y", "Z", "C", "D"]
+    #   Hamster::Vector[].insert(2, "X", "Y", "Z")
+    #   # => Hamster::Vector[nil, nil, "X", "Y", "Z"]
     #
     # @param index [Integer] The index where the new items should go
     # @param items [Array] The items to add
     # @return [Vector]
+    # @raise [IndexError] if index exceeds negative range.
     def insert(index, *items)
       raise IndexError if index < -@size
       index += @size if index < 0
@@ -259,6 +363,10 @@ module Hamster
     # Return a new `Vector` with the element at `index` removed. If the given `index`
     # does not exist, return `self`.
     #
+    # @example
+    #   Hamster::Vector["A", "B", "C", "D"].delete_at(2)
+    #   # => Hamster::Vector["A", "B", "D"]
+    #
     # @param index [Integer] The index to remove
     # @return [Vector]
     def delete_at(index)
@@ -269,40 +377,70 @@ module Hamster
       replace_suffix(index, suffix.tap { |a| a.shift })
     end
 
-    # Return a new `Vector` with the last element removed. If empty, just return `self`.
+    # Return a new `Vector` with the last element removed. Return `self` if
+    # empty.
+    #
+    # @example
+    #   Hamster::Vector["A", "B", "C"].pop  # => Hamster::Vector["A", "B"]
+    #
     # @return [Vector]
     def pop
       return self if @size == 0
       replace_suffix(@size-1, [])
     end
 
-    # Return a new `Vector` with `obj` inserted before the first element, moving
-    # the other elements upwards.
-    # @param obj [Object] The value to prepend
+    # Return a new `Vector` with `object` inserted before the first element,
+    # moving the other elements upwards.
+    #
+    # @example
+    #   Hamster::Vector["A", "B"].unshift("Z")
+    #   # => Hamster::Vector["Z", "A", "B"]
+    #
+    # @param object [Object] The value to prepend
     # @return [Vector]
-    def unshift(obj)
-      insert(0, obj)
+    def unshift(object)
+      insert(0, object)
     end
 
-    # Return a new `Vector` with the first element removed. If empty, just return `self`.
+    # Return a new `Vector` with the first element removed. If empty, return
+    # `self`.
+    #
+    # @example
+    #   Hamster::Vector["A", "B", "C"].shift  # => Hamster::Vector["B", "C"]
+    #
     # @return [Vector]
     def shift
       delete_at(0)
     end
 
     # Call the given block once for each item in the vector, passing each
-    # item from first to last successively to the block.
+    # item from first to last successively to the block. If no block is given,
+    # an `Enumerator` is returned instead.
     #
-    # @return [self]
+    # @example
+    #   Hamster::Vector["A", "B", "C"].each { |e| puts "Element: #{e}" }
+    #
+    #   Element: A
+    #   Element: B
+    #   Element: C
+    #   # => Hamster::Vector["A", "B", "C"]
+    #
+    # @return [self, Enumerator]
     def each(&block)
       return to_enum unless block_given?
       traverse_depth_first(@root, @levels, &block)
       self
     end
 
-    # Call the given block once for each item in the vector, passing each
-    # item starting from the last, and counting back to the first, successively to
-    # the block.
+    # Call the given block once for each item in the vector, from last to
+    # first.
+    #
+    # @example
+    #   Hamster::Vector["A", "B", "C"].reverse_each { |e| puts "Element: #{e}" }
+    #
+    #   Element: C
+    #   Element: B
+    #   Element: A
     #
     # @return [self]
     def reverse_each(&block)
@@ -314,34 +452,65 @@ module Hamster
     # Return a new `Vector` containing all elements for which the given block returns
     # true.
     #
+    # @example
+    #   Hamster::Vector["Bird", "Cow", "Elephant"].select { |e| e.size >= 4 }
+    #   # => Hamster::Vector["Bird", "Elephant"]
+    #
     # @return [Vector]
-    def filter
-      return enum_for(:filter) unless block_given?
+    # @yield [element] Once for each element.
+    def select
+      return enum_for(:select) unless block_given?
       reduce(self.class.empty) { |vector, item| yield(item) ? vector.add(item) : vector }
     end
+    alias :find_all :select
+    alias :keep_if  :select
 
     # Return a new `Vector` with all items which are equal to `obj` removed.
     # `#==` is used for checking equality.
     #
+    # @example
+    #   Hamster::Vector["C", "B", "A", "B"].delete("B")  # => Hamster::Vector["C", "A"]
+    #
     # @param obj [Object] The object to remove (every occurrence)
     # @return [Vector]
     def delete(obj)
-      filter { |item| item != obj }
+      select { |item| item != obj }
     end
 
     # Invoke the given block once for each item in the vector, and return a new
-    # `Vector` containing the values returned by the block.
+    # `Vector` containing the values returned by the block. If no block is
+    # provided, return an enumerator.
     #
-    # @return [Vector]
+    # @example
+    #   Hamster::Vector[3, 2, 1].map { |e| e * e }  # => Hamster::Vector[9, 4, 1]
+    #
+    # @return [Vector, Enumerator]
     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 a new `Vector` with the concatenated results of running the block once
+    # for every element in this `Vector`.
+    #
+    # @example
+    #   Hamster::Vector[1, 2, 3].flat_map { |x| [x, -x] }
+    #   # => Hamster::Vector[1, -1, 2, -2, 3, -3]
+    #
+    # @return [Vector]
+    def flat_map
+      return enum_for(:flat_map) if not block_given?
+      return self if empty?
+      self.class.new(super)
+    end
 
     # Return a new `Vector` with the same elements as this one, but randomly permuted.
     #
+    # @example
+    #   Hamster::Vector[1, 2, 3, 4].shuffle  # => Hamster::Vector[4, 1, 3, 2]
+    #
     # @return [Vector]
     def shuffle
       self.class.new(((array = to_a).frozen? ? array.shuffle : array.shuffle!).freeze)
@@ -350,13 +519,35 @@ module Hamster
     # Return a new `Vector` with no duplicate elements, as determined by `#hash` and
     # `#eql?`. For each group of equivalent elements, only the first will be retained.
     #
+    # @example
+    #   Hamster::Vector["A", "B", "C", "B"].uniq      # => Hamster::Vector["A", "B", "C"]
+    #   Hamster::Vector["a", "A", "b"].uniq(&:upcase) # => Hamster::Vector["a", "b"]
+    #
     # @return [Vector]
-    def uniq
-      self.class.new(((array = to_a).frozen? ? array.uniq : array.uniq!).freeze)
+    def uniq(&block)
+      array = self.to_a
+      if block_given?
+        if array.frozen?
+          self.class.new(array.uniq(&block).freeze)
+        elsif array.uniq!(&block) # returns nil if no changes were made
+          self.class.new(array.freeze)
+        else
+          self
+        end
+      elsif array.frozen?
+        self.class.new(array.uniq.freeze)
+      elsif array.uniq! # returns nil if no changes were made
+        self.class.new(array.freeze)
+      else
+        self
+      end
     end
 
     # Return a new `Vector` with the same elements as this one, but in reverse order.
     #
+    # @example
+    #   Hamster::Vector["A", "B", "C"].reverse  # => Hamster::Vector["C", "B", "A"]
+    #
     # @return [Vector]
     def reverse
       self.class.new(((array = to_a).frozen? ? array.reverse : array.reverse!).freeze)
@@ -368,6 +559,11 @@ module Hamster
     # will be moved to the end. If `count` is negative, the elements will be shifted
     # right, and those shifted past the last position will be moved to the beginning.
     #
+    # @example
+    #   v = Hamster::Vector["A", "B", "C", "D", "E", "F"]
+    #   v.rotate(2)   # => Hamster::Vector["C", "D", "E", "F", "A", "B"]
+    #   v.rotate(-1)  # => Hamster::Vector["F", "A", "B", "C", "D", "E"]
+    #
     # @param count [Integer] The number of positions to shift items by
     # @return [Vector]
     def rotate(count = 1)
@@ -376,22 +572,40 @@ module Hamster
     end
 
     # Return a new `Vector` with all nested vectors and arrays recursively "flattened
-    # out", that is, their elements inserted into the new `Vector` in the place where
+    # out". That is, their elements inserted into the new `Vector` in the place where
     # the nested array/vector originally was. If an optional `level` argument is
     # provided, the flattening will only be done recursively that number of times.
     # A `level` of 0 means not to flatten at all, 1 means to only flatten nested
     # arrays/vectors which are directly contained within this `Vector`.
     #
+    # @example
+    #   v = Hamster::Vector["A", Hamster::Vector["B", "C", Hamster::Vector["D"]]]
+    #   v.flatten(1)
+    #   # => Hamster::Vector["A", "B", "C", Hamster::Vector["D"]]
+    #   v.flatten
+    #   # => Hamster::Vector["A", "B", "C", "D"]
+    #
     # @param level [Integer] The depth to which flattening should be applied
     # @return [Vector]
-    def flatten(level = nil)
+    def flatten(level = -1)
       return self if level == 0
-      self.class.new(((array = to_a).frozen? ? array.flatten(level) : array.flatten!(level)).freeze)
+      array = self.to_a
+      if array.frozen?
+        self.class.new(array.flatten(level).freeze)
+      elsif array.flatten!(level) # returns nil if no changes were made
+        self.class.new(array.freeze)
+      else
+        self
+      end
     end
 
     # Return a new `Vector` built by concatenating this one with `other`. `other`
     # can be any object which is convertible to an `Array` using `#to_a`.
     #
+    # @example
+    #   Hamster::Vector["A", "B", "C"] + ["D", "E"]
+    #   # => Hamster::Vector["A", "B", "C", "D", "E"]
+    #
     # @param other [Enumerable] The collection to concatenate onto this vector
     # @return [Vector]
     def +(other)
@@ -399,17 +613,33 @@ module Hamster
       other = other.dup if other.frozen?
       replace_suffix(@size, other)
     end
-    def_delegator :self, :+, :concat
+    alias :concat :+
 
-    # `others` should be arrays and/or vectors. The corresponding elements from this
-    # `Vector` and each of `others` (that is, the elements with the same indices)
-    # will be gathered into arrays.
+    # Combine two vectors by "zipping" them together. `others` should be arrays
+    # and/or vectors. The corresponding elements from this `Vector` and each of
+    # `others` (that is, the elements with the same indices) will be gathered
+    # into arrays.
+    #
+    # If `others` contains fewer elements than this vector, `nil` will be used
+    # for padding.
     #
-    # If an optional block is provided, each such array will be passed successively
-    # to the block. Otherwise, a new `Vector` of all those arrays will be returned.
+    # @overload zip(*others)
+    #   Return a new vector containing the new arrays.
+    #
+    #   @return [Vector]
+    #
+    # @overload zip(*others)
+    #   @yield [pair] once for each array
+    #   @return [nil]
+    #
+    # @example
+    #   v1 = Hamster::Vector["A", "B", "C"]
+    #   v2 = Hamster::Vector[1, 2]
+    #   v1.zip(v2)
+    #   # => Hamster::Vector[["A", 1], ["B", 2], ["C", nil]]
     #
     # @param others [Array] The arrays/vectors to zip together with this one
-    # @return [Vector, nil]
+    # @return [Vector]
     def zip(*others)
       if block_given?
         super
@@ -418,20 +648,41 @@ module Hamster
       end
     end
 
-    # Return a new `Vector` with the same items, but sorted. The sort order will
-    # be determined by comparing items using `#<=>`, or if an optional code block
-    # is provided, by using it as a comparator. The block should accept 2 parameters,
-    # and should return 0, 1, or -1 if the first parameter is equal to, greater than,
-    # or less than the second parameter (respectively).
+    # Return a new `Vector` with the same items, but sorted.
+    #
+    # @overload sort
+    #   Compare elements with their natural sort key (`#<=>`).
+    #
+    #   @example
+    #     Hamster::Vector["Elephant", "Dog", "Lion"].sort
+    #     # => Hamster::Vector["Dog", "Elephant", "Lion"]
+    #
+    # @overload sort
+    #   Uses the block as a comparator to determine sorted order.
+    #
+    #   @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.
+    #   @example
+    #     Hamster::Vector["Elephant", "Dog", "Lion"].sort { |a,b| a.size <=> b.size }
+    #     # => Hamster::Vector["Dog", "Lion", "Elephant"]
     #
     # @return [Vector]
     def sort
       self.class.new(super)
     end
 
-    # Return a new `Vector` with the same items, but sorted. The sort order will be
-    # determined by mapping the items through the given block to obtain sort keys,
-    # and then sorting the keys according to their natural sort order.
+    # Return a new `Vector` with the same items, but sorted. The sort order is
+    # determined by mapping the items through the given block to obtain sort
+    # keys, and then sorting the keys according to their natural sort order
+    # (`#<=>`).
+    #
+    # @yield [element] Once for each element.
+    # @yieldreturn a sort key object for the yielded element.
+    # @example
+    #   Hamster::Vector["Elephant", "Dog", "Lion"].sort_by { |e| e.size }
+    #   # => Hamster::Vector["Dog", "Lion", "Elephant"]
     #
     # @return [Vector]
     def sort_by
@@ -439,16 +690,31 @@ module Hamster
     end
 
     # Drop the first `n` elements and return the rest in a new `Vector`.
+    #
+    # @example
+    #   Hamster::Vector["A", "B", "C", "D", "E", "F"].drop(2)
+    #   # => Hamster::Vector["C", "D", "E", "F"]
+    #
     # @param n [Integer] The number of elements to remove
     # @return [Vector]
+    # @raise ArgumentError if `n` is negative.
     def drop(n)
-      self.class.new(super)
+      return self if n == 0
+      return self.class.empty if n >= @size
+      raise ArgumentError, "attempt to drop negative size" if n < 0
+      self.class.new(flatten_suffix(@root, @levels * BITS_PER_LEVEL, n, []))
     end
 
     # Return only the first `n` elements in a new `Vector`.
+    #
+    # @example
+    #   Hamster::Vector["A", "B", "C", "D", "E", "F"].take(4)
+    #   # => Hamster::Vector["A", "B", "C", "D"]
+    #
     # @param n [Integer] The number of elements to retain
     # @return [Vector]
     def take(n)
+      return self if n >= @size
       self.class.new(super)
     end
 
@@ -456,6 +722,10 @@ module Hamster
     # block returns `nil` or `false`. Gather the remaining elements into a new
     # `Vector`. If no block is given, an `Enumerator` is returned instead.
     #
+    # @example
+    #   Hamster::Vector[1, 3, 5, 7, 6, 4, 2].drop_while { |e| e < 5 }
+    #   # => Hamster::Vector[5, 7, 6, 4, 2]
+    #
     # @return [Vector, Enumerator]
     def drop_while
       return enum_for(:drop_while) if not block_given?
@@ -466,6 +736,10 @@ module Hamster
     # block returns `nil` or `false`, and return them in a new `Vector`. If no block
     # is given, an `Enumerator` is returned instead.
     #
+    # @example
+    #   Hamster::Vector[1, 3, 5, 7, 6, 4, 2].take_while { |e| e < 5 }
+    #   # => Hamster::Vector[1, 3]
+    #
     # @return [Vector, Enumerator]
     def take_while
       return enum_for(:take_while) if not block_given?
@@ -475,6 +749,10 @@ module Hamster
     # Repetition. Return a new `Vector` built by concatenating `times` copies
     # of this one together.
     #
+    # @example
+    #   Hamster::Vector["A", "B"] * 3
+    #   # => Hamster::Vector["A", "B", "A", "B", "A", "B"]
+    #
     # @param times [Integer] The number of times to repeat the elements in this vector
     # @return [Vector]
     def *(times)
@@ -486,28 +764,53 @@ module Hamster
 
     # Replace a range of indexes with the given object.
     #
-    # @overload fill(obj)
-    #   Return a new `Vector` of the same size, with every index set to `obj`.
-    # @overload fill(obj, start)
-    #   Return a new `Vector` with all indexes from `start` to the end of the
-    #   vector set to `obj`.
-    # @overload fill(obj, start, length)
-    #   Return a new `Vector` with `length` indexes, beginning from `start`,
-    #   set to `obj`.
+    # @overload fill(object)
+    #   Return a new `Vector` of the same size, with every index set to
+    #   `object`.
+    #
+    #   @param [Object] object Fill value.
+    #   @example
+    #     Hamster::Vector["A", "B", "C", "D", "E", "F"].fill("Z")
+    #     # => Hamster::Vector["Z", "Z", "Z", "Z", "Z", "Z"]
+    #
+    # @overload fill(object, index)
+    #   Return a new `Vector` with all indexes from `index` to the end of the
+    #   vector set to `object`.
+    #
+    #   @param [Object] object Fill value.
+    #   @param [Integer] index Starting index. May be negative.
+    #   @example
+    #     Hamster::Vector["A", "B", "C", "D", "E", "F"].fill("Z", 3)
+    #     # => Hamster::Vector["A", "B", "C", "Z", "Z", "Z"]
+    #
+    # @overload fill(object, index, length)
+    #   Return a new `Vector` with `length` indexes, beginning from `index`,
+    #   set to `object`. Expands the `Vector` if `length` would extend beyond
+    #   the current length.
+    #
+    #   @param [Object] object Fill value.
+    #   @param [Integer] index Starting index. May be negative.
+    #   @param [Integer] length
+    #   @example
+    #     Hamster::Vector["A", "B", "C", "D", "E", "F"].fill("Z", 3, 2)
+    #     # => Hamster::Vector["A", "B", "C", "Z", "Z", "F"]
+    #     Hamster::Vector["A", "B"].fill("Z", 1, 5)
+    #     # => Hamster::Vector["A", "Z", "Z", "Z", "Z", "Z"]
     #
     # @return [Vector]
-    def fill(obj, index = 0, length = nil)
+    # @raise [IndexError] if index is out of negative range.
+    def fill(object, index = 0, length = nil)
       raise IndexError if index < -@size
       index += @size if index < 0
       length ||= @size - index # to the end of the array, if no length given
 
       if index < @size
         suffix = flatten_suffix(@root, @levels * BITS_PER_LEVEL, index, [])
-        suffix.fill(obj, 0, length)
+        suffix.fill(object, 0, length)
       elsif index == @size
-        suffix = Array.new(length, obj)
+        suffix = Array.new(length, object)
       else
-        suffix = Array.new(index - @size, nil).concat(Array.new(length, obj))
+        suffix = Array.new(index - @size, nil).concat(Array.new(length, object))
         index = @size
       end
 
@@ -516,10 +819,20 @@ module Hamster
 
     # When invoked with a block, yields all combinations of length `n` of items
     # from the `Vector`, and then returns `self`. There is no guarantee about
-    # which order the combinations will be yielded in.
+    # which order the combinations will be yielded.
     #
     # If no block is given, an `Enumerator` is returned instead.
     #
+    # @example
+    #   v = Hamster::Vector[5, 6, 7, 8]
+    #   v.combination(3) { |c| puts "Combination: #{c}" }
+    #
+    #   Combination: [5, 6, 7]
+    #   Combination: [5, 6, 8]
+    #   Combination: [5, 7, 8]
+    #   Combination: [6, 7, 8]
+    #   #=> Hamster::Vector[5, 6, 7, 8]
+    #
     # @return [self, Enumerator]
     def combination(n)
       return enum_for(:combination, n) if not block_given?
@@ -557,6 +870,22 @@ module Hamster
     #
     # If no block is given, an `Enumerator` is returned instead.
     #
+    # @example
+    #   v = Hamster::Vector[5, 6, 7, 8]
+    #   v.repeated_combination(2) { |c| puts "Combination: #{c}" }
+    #
+    #   Combination: [5, 5]
+    #   Combination: [5, 6]
+    #   Combination: [5, 7]
+    #   Combination: [5, 8]
+    #   Combination: [6, 6]
+    #   Combination: [6, 7]
+    #   Combination: [6, 8]
+    #   Combination: [7, 7]
+    #   Combination: [7, 8]
+    #   Combination: [8, 8]
+    #   # => Hamster::Vector[5, 6, 7, 8]
+    #
     # @return [self, Enumerator]
     def repeated_combination(n)
       return enum_for(:repeated_combination, n) if not block_given?
@@ -595,6 +924,18 @@ module Hamster
     #
     # If no block is given, an `Enumerator` is returned instead.
     #
+    # @example
+    #   v = Hamster::Vector[5, 6, 7]
+    #   v.permutation(2) { |p| puts "Permutation: #{p}" }
+    #
+    #   Permutation: [5, 6]
+    #   Permutation: [5, 7]
+    #   Permutation: [6, 5]
+    #   Permutation: [6, 7]
+    #   Permutation: [7, 5]
+    #   Permutation: [7, 6]
+    #   # => Hamster::Vector[5, 6, 7]
+    #
     # @return [self, Enumerator]
     def permutation(n = @size)
       return enum_for(:permutation, n) if not block_given?
@@ -635,6 +976,21 @@ module Hamster
     #
     # If no block is given, an `Enumerator` is returned instead.
     #
+    # @example
+    #   v = Hamster::Vector[5, 6, 7]
+    #   v.repeated_permutation(2) { |p| puts "Permutation: #{p}" }
+    #
+    #   Permutation: [5, 5]
+    #   Permutation: [5, 6]
+    #   Permutation: [5, 7]
+    #   Permutation: [6, 5]
+    #   Permutation: [6, 6]
+    #   Permutation: [6, 7]
+    #   Permutation: [7, 5]
+    #   Permutation: [7, 6]
+    #   Permutation: [7, 7]
+    #   # => Hamster::Vector[5, 6, 7]
+    #
     # @return [self, Enumerator]
     def repeated_permutation(n = @size)
       return enum_for(:repeated_permutation, n) if not block_given?
@@ -661,17 +1017,23 @@ module Hamster
       self
     end
 
-    # With one or more vector or array arguments, return the cartesian product of
-    # this vector's elements and those of each argument; with no arguments, return the
-    # result of multiplying all this vector's items together.
+    # Cartesian product or multiplication.
     #
     # @overload product(*vectors)
     #   Return a `Vector` of all combinations of elements from this `Vector` and each
     #   of the given vectors or arrays. The length of the returned `Vector` is the product
     #   of `self.size` and the size of each argument vector or array.
+    #   @example
+    #     v1 = Hamster::Vector[1, 2, 3]
+    #     v2 = Hamster::Vector["A", "B"]
+    #     v1.product(v2)
+    #     # => [[1, "A"], [1, "B"], [2, "A"], [2, "B"], [3, "A"], [3, "B"]]
     # @overload product
     #   Return the result of multiplying all the items in this `Vector` together.
     #
+    #   @example
+    #     Hamster::Vector[1, 2, 3, 4, 5].product  # => 120
+    #
     # @return [Vector]
     def product(*vectors)
       # if no vectors passed, return "product" as in result of multiplying all items
@@ -726,7 +1088,13 @@ module Hamster
     # calling {#zip} on the first nested vector/array with the others supplied as
     # arguments.
     #
+    # @example
+    #   Hamster::Vector[["A", 10], ["B", 20], ["C", 30]].transpose
+    #   # => Hamster::Vector[Hamster::Vector["A", "B", "C"], Hamster::Vector[10, 20, 30]]
+    #
     # @return [Vector]
+    # @raise [IndexError] if elements are not of the same size.
+    # @raise [TypeError] if an element can not be implicitly converted to an array (using `#to_ary`)
     def transpose
       return self.class.empty if empty?
       result = Array.new(first.size) { [] }
@@ -746,12 +1114,28 @@ module Hamster
       self.class.new(result)
     end
 
-    # By using binary search, finds a value from this `Vector` which meets the
-    # condition defined by the provided block. Behavior is just like `Array#bsearch`.
-    # See `Array#bsearch` for details.
+    # Finds a value from this `Vector` which meets the condition defined by the
+    # provided block, using a binary search. The vector must already be sorted
+    # with respect to the block.  See Ruby's `Array#bsearch` for details,
+    # behaviour is equivalent.
     #
-    # @return [Object]
+    # @example
+    #   v = Hamster::Vector[1, 3, 5, 7, 9, 11, 13]
+    #   # Block returns true/false for exact element match:
+    #   v.bsearch { |e| e > 4 }      # => 5
+    #   # Block returns number to match an element in 4 <= e <= 7:
+    #   v.bsearch { |e| 1 - e / 4 }  # => 7
+    #
+    # @yield Once for at most `log n` elements, where `n` is the size of the
+    #        vector. The exact elements and ordering are undefined.
+    # @yieldreturn [Boolean] `true` if this element matches the criteria, `false` otherwise.
+    # @yieldreturn [Integer] See `Array#bsearch` for details.
+    # @yieldparam [Object] element element to be evaluated
+    # @return [Object] The matched element, or `nil` if none found.
+    # @raise TypeError if the block returns a non-numeric, non-boolean, non-nil
+    #                  value.
     def bsearch
+      return enum_for(:bsearch) if not block_given?
       low, high, result = 0, @size, nil
       while low < high
         mid = (low + ((high - low) >> 1))
@@ -787,6 +1171,9 @@ module Hamster
 
     # Return a randomly chosen item from this `Vector`. If the vector is empty, return `nil`.
     #
+    # @example
+    #   Hamster::Vector[1, 2, 3, 4, 5].sample  # => 2
+    #
     # @return [Object]
     def sample
       get(rand(@size))
@@ -796,23 +1183,36 @@ module Hamster
     # order specified by `indices`. If any of the `indices` do not exist, `nil`s will
     # appear in their places.
     #
+    # @example
+    #   v = Hamster::Vector["A", "B", "C", "D", "E", "F"]
+    #   v.values_at(2, 4, 5)   # => Hamster::Vector["C", "E", "F"]
+    #
     # @param indices [Array] The indices to retrieve and gather into a new `Vector`
     # @return [Vector]
     def values_at(*indices)
       self.class.new(indices.map { |i| get(i) }.freeze)
     end
 
-    # Return the index of the last element which is equal to the provided object,
-    # or for which the provided block returns true.
+    # Find the index of an element, starting from the end of the vector.
+    # Returns `nil` if no element is found.
     #
     # @overload rindex(obj)
-    #   Return the index of the last element in this `Vector` which is `#==` to `obj`.
-    # @overload rindex { |item| ... }
-    #   Return the index of the last element in this `Vector` for which the block
-    #   returns true. (Iteration starts from the last element, counts back, and
-    #   stops as soon as a matching element is found.)
+    #   Return the index of the last element which is `#==` to `obj`.
+    #
+    #   @example
+    #     v = Hamster::Vector[7, 8, 9, 7, 8, 9]
+    #     v.rindex(8) # => 4
+    #
+    # @overload rindex
+    #   Return the index of the last element for which the block returns true.
     #
-    # @return [Index]
+    #   @yield [element] Once for each element, last to first, until the block
+    #                    returns true.
+    #   @example
+    #     v = Hamster::Vector[7, 8, 9, 7, 8, 9]
+    #     v.rindex { |e| e.even? }  # => 4
+    #
+    # @return [Integer]
     def rindex(obj = (missing_arg = true))
       i = @size - 1
       if missing_arg
@@ -831,22 +1231,40 @@ module Hamster
     # Assumes all elements are nested, indexable collections, and searches through them,
     # comparing `obj` with the first element of each nested collection. Return the
     # first nested collection which matches, or `nil` if none is found.
+    # Behaviour is undefined when elements do not meet assumptions (i.e. are
+    # not indexable collections).
+    #
+    # @example
+    #   v = Hamster::Vector[["A", 10], ["B", 20], ["C", 30]]
+    #   v.assoc("B")  # => ["B", 20]
     #
     # @param obj [Object] The object to search for
     # @return [Object]
     def assoc(obj)
-      each { |array| return array if obj == array[0] }
+      each do |array|
+        next if !array.respond_to?(:[])
+        return array if obj == array[0]
+      end
       nil
     end
 
     # Assumes all elements are nested, indexable collections, and searches through them,
-    # comparing `obj` with the second element of each nested collection. Return the
-    # first nested collection which matches, or `nil` if none is found.
+    # comparing `obj` with the second element of each nested collection. Return
+    # the first nested collection which matches, or `nil` if none is found.
+    # Behaviour is undefined when elements do not meet assumptions (i.e. are
+    # not indexable collections).
+    #
+    # @example
+    #   v = Hamster::Vector[["A", 10], ["B", 20], ["C", 30]]
+    #   v.rassoc(20)  # => ["B", 20]
     #
     # @param obj [Object] The object to search for
     # @return [Object]
     def rassoc(obj)
-      each { |array| return array if obj == array[1] }
+      each do |array|
+        next if !array.respond_to?(:[])
+        return array if obj == array[1]
+      end
       nil
     end
 
@@ -856,11 +1274,14 @@ module Hamster
     # @return [Array]
     def to_a
       if @levels == 0
+        # When initializing a Vector with 32 or less items, we always make
+        # sure @root is frozen, so we can return it directly here
         @root
       else
         flatten_node(@root, @levels * BITS_PER_LEVEL, [])
       end
     end
+    alias :to_ary :to_a
 
     # Return true if `other` has the same type and contents as this `Vector`.
     #
@@ -915,8 +1336,12 @@ module Hamster
         root = [root].freeze
         levels += 1
       end
-      root = update_leaf_node(root, levels * BITS_PER_LEVEL, index, item)
-      self.class.alloc(root, @size > index ? @size : index + 1, levels)
+      new_root = update_leaf_node(root, levels * BITS_PER_LEVEL, index, item)
+      if new_root.equal?(root)
+        self
+      else
+        self.class.alloc(new_root, @size > index ? @size : index + 1, levels)
+      end
     end
 
     def update_leaf_node(node, bitshift, index, item)
@@ -925,7 +1350,12 @@ module Hamster
         old_child = node[slot_index] || []
         item = update_leaf_node(old_child, bitshift - BITS_PER_LEVEL, index, item)
       end
-      node.dup.tap { |n| n[slot_index] = item }.freeze
+      existing_item = node[slot_index]
+      if existing_item.equal?(item)
+        node
+      else
+        node.dup.tap { |n| n[slot_index] = item }.freeze
+      end
     end
 
     def flatten_range(node, bitshift, from, to)
@@ -1082,9 +1512,10 @@ module Hamster
     end
   end
 
-  # The canonical empty `Vector`. Returned by `Hamster.vector` and `Vector[]` when
+  # The canonical empty `Vector`. Returned by `Vector[]` when
   # invoked with no arguments; also returned by `Vector.empty`. Prefer using this
   # one rather than creating many empty vectors using `Vector.new`.
   #
+  # @private
   EmptyVector = Hamster::Vector.empty
 end