immutable-ruby 0.0.1 → 0.1.0

data/lib/immutable/sorted_set.rb

@@ -1,4 +1,4 @@
-require "immutable/enumerable"
+require 'immutable/enumerable'
 
 module Immutable
 
@@ -65,7 +65,7 @@ module Immutable
       #
       # @return [SortedSet]
       def empty
-        @empty ||= self.alloc(PlainAVLNode::EmptyNode)
+        @empty ||= alloc(PlainAVLNode::EmptyNode)
       end
 
       # "Raw" allocation of a new `SortedSet`. Used internally to create a new
@@ -76,21 +76,46 @@ module Immutable
       def alloc(node)
         allocate.tap { |s| s.instance_variable_set(:@node, node) }.freeze
       end
+
+      # @private
+      # Unfortunately, Ruby's stdlib doesn't do this for us
+      # array must be sorted
+      def uniq_by_comparator!(array, comparator)
+        to_check, shift, sz, prev_obj = 1, 0, array.size, array[0]
+        while to_check < sz
+          next_obj = array[to_check]
+          if comparator.call(prev_obj, next_obj) == 0
+            shift += 1
+          else
+            if shift > 0
+              array[to_check - shift] = next_obj
+            end
+            prev_obj = next_obj
+          end
+          to_check += 1
+        end
+        array.pop(shift) if shift > 0
+      end
     end
 
     def initialize(items=[], &block)
       items = items.to_a
       if block
-        if block.arity == 1 || block.arity == -1
+        # In Ruby 2, &:method blocks have arity -1; in Ruby 3, it's -2
+        if block.arity == 1 || block.arity == -1 || block.arity == -2
+          items = items.uniq(&block)
+          items.sort_by!(&block)
           comparator = lambda { |a,b| block.call(a) <=> block.call(b) }
-          items = items.sort_by(&block)
-        else
-          comparator = block
+        elsif block.arity == 2 || block.arity == -3
           items = items.sort(&block)
+          SortedSet.uniq_by_comparator!(items, block)
+          comparator = block
+        else
+          raise "Comparator block for Immutable::SortedSet must accept 1 or 2 arguments"
         end
         @node = AVLNode.from_items(items, comparator)
       else
-        @node = PlainAVLNode.from_items(items.sort)
+        @node = PlainAVLNode.from_items(items.uniq.sort!)
       end
       freeze
     end
@@ -111,7 +136,7 @@ module Immutable
     def size
       @node.size
     end
-    alias :length :size
+    alias length size
 
     # Return a new `SortedSet` with `item` added. If `item` is already in the set,
     # return `self`.
@@ -129,7 +154,7 @@ module Immutable
       end
       self
     end
-    alias :<< :add
+    alias << add
 
     # If `item` is not a member of this `SortedSet`, return a new `SortedSet` with
     # `item` added. Otherwise, return `false`.
@@ -321,7 +346,7 @@ module Immutable
         subsequence(arg, length)
       end
     end
-    alias :[] :slice
+    alias [] slice
 
     # Return a new `SortedSet` with only the elements at the given `indices`.
     # If any of the `indices` do not exist, they will be skipped.
@@ -429,8 +454,8 @@ module Immutable
       each { |item| items_to_delete << item unless yield(item) }
       derive_new_sorted_set(@node.bulk_delete(items_to_delete))
     end
-    alias :find_all :select
-    alias :keep_if  :select
+    alias find_all select
+    alias keep_if  select
 
     # Invoke the given block once for each item in the set, and return a new
     # `SortedSet` containing the values returned by the block. If no block is
@@ -447,7 +472,7 @@ module Immutable
       return self if empty?
       self.class.alloc(@node.from_items(super))
     end
-    alias :collect :map
+    alias collect map
 
     # Return `true` if the given item is present in this `SortedSet`. More precisely,
     # return `true` if an object which compares as "equal" using this set's
@@ -461,7 +486,7 @@ module Immutable
     def include?(item)
       @node.include?(item)
     end
-    alias :member? :include?
+    alias member? include?
 
     # Return a new `SortedSet` with the same items, but a sort order determined
     # by the given block.
@@ -475,12 +500,14 @@ module Immutable
     # @return [SortedSet]
     def sort(&block)
       if block
-        self.class.new(self.to_a, &block)
+        self.class.new(to_a, &block)
+      elsif @node.natural_order?
+        self
       else
-        self.class.new(self.to_a.sort)
-      end      
+        self.class.new(self)
+      end
     end
-    alias :sort_by :sort
+    alias sort_by sort
 
     # Find the index of a given object or an element that satisfies the given
     # block.
@@ -526,7 +553,7 @@ module Immutable
         super(&block)
       end
     end
-    alias :index :find_index
+    alias index find_index
 
     # Drop the first `n` elements and return the rest in a new `SortedSet`.
     #
@@ -604,9 +631,9 @@ module Immutable
     def union(other)
       self.class.alloc(@node.bulk_insert(other))
     end
-    alias :| :union
-    alias :+ :union
-    alias :merge :union
+    alias | union
+    alias + union
+    alias merge union
 
     # Return a new `SortedSet` which contains all the items which are members of both
     # this set and `other`. `other` can be any `Enumerable` object.
@@ -620,7 +647,7 @@ module Immutable
     def intersection(other)
       self.class.alloc(@node.keep_only(other))
     end
-    alias :& :intersection
+    alias & intersection
 
     # Return a new `SortedSet` with all the items in `other` removed. `other` can be
     # any `Enumerable` object.
@@ -634,8 +661,8 @@ module Immutable
     def difference(other)
       self.class.alloc(@node.bulk_delete(other))
     end
-    alias :subtract :difference
-    alias :- :difference
+    alias subtract difference
+    alias - difference
 
     # Return a new `SortedSet` with all the items which are members of this
     # set or of `other`, but not both. `other` can be any `Enumerable` object.
@@ -649,7 +676,7 @@ module Immutable
     def exclusion(other)
       ((self | other) - (self & other))
     end
-    alias :^ :exclusion
+    alias ^ exclusion
 
     # Return `true` if all items in this set are also in `other`.
     #
@@ -728,8 +755,8 @@ module Immutable
       !disjoint?(other)
     end
 
-    alias :group :group_by
-    alias :classify :group_by
+    alias group group_by
+    alias classify group_by
 
     # Select elements greater than a value.
     #
@@ -923,10 +950,11 @@ module Immutable
       return true if other.equal?(self)
       return false if not instance_of?(other.class)
       return false if size != other.size
-      a, b = self.to_enum, other.to_enum
-      while true
+      a, b = to_enum, other.to_enum
+      loop do
         return false if !a.next.eql?(b.next)
       end
+      true
     rescue StopIteration
       true
     end
@@ -943,7 +971,7 @@ module Immutable
     def dup
       self
     end
-    alias :clone :dup
+    alias clone dup
 
     # @return [::Array]
     # @private
@@ -990,7 +1018,8 @@ module Immutable
 
     # @private
     class AVLNode
-      def self.from_items(items, comparator, from = 0, to = items.size-1) # items must be sorted
+      def self.from_items(items, comparator, from = 0, to = items.size-1)
+        # items must be sorted, without duplicates (as determined by comparator)
         size = to - from + 1
         if size >= 3
           middle = (to + from) / 2
@@ -1013,8 +1042,12 @@ module Immutable
       end
       attr_reader :item, :left, :right, :height, :size
 
+      # Used to implement #map
+      # Takes advantage of the fact that Enumerable#map allocates a new Array
       def from_items(items)
-        AVLNode.from_items(items.sort(&@comparator), @comparator)
+        items.sort!(&@comparator)
+        SortedSet.uniq_by_comparator!(items, @comparator)
+        AVLNode.from_items(items, @comparator)
       end
 
       def natural_order?
@@ -1374,7 +1407,9 @@ module Immutable
         end
         def bulk_insert(items)
           items = items.to_a if !items.is_a?(Array)
-          AVLNode.from_items(items.sort(&@comparator), @comparator)
+          items = items.sort(&@comparator)
+          SortedSet.uniq_by_comparator!(items, @comparator)
+          AVLNode.from_items(items, @comparator)
         end
         def bulk_delete(items); self; end
         def keep_only(items);   self; end
@@ -1397,7 +1432,8 @@ module Immutable
     # AVL node which does not use a comparator function; it keeps items sorted
     #   in their natural order
     class PlainAVLNode < AVLNode
-      def self.from_items(items, from = 0, to = items.size-1) # items must be sorted
+      def self.from_items(items, from = 0, to = items.size-1)
+        # items must be sorted, with no duplicates
         size = to - from + 1
         if size >= 3
           middle = (to + from) / 2
@@ -1418,8 +1454,12 @@ module Immutable
       end
       attr_reader :item, :left, :right, :height, :size
 
+      # Used to implement #map
+      # Takes advantage of the fact that Enumerable#map allocates a new Array
       def from_items(items)
-        PlainAVLNode.from_items(items.sort)
+        items.uniq!
+        items.sort!
+        PlainAVLNode.from_items(items)
       end
 
       def natural_order?
@@ -1447,7 +1487,7 @@ module Immutable
         end
         def bulk_insert(items)
           items = items.to_a if !items.is_a?(Array)
-          PlainAVLNode.from_items(items.sort)
+          PlainAVLNode.from_items(items.uniq.sort!)
         end
       end
 

data/lib/immutable/trie.rb

@@ -2,7 +2,7 @@ module Immutable
   # @private
   class Trie
     def self.[](pairs)
-      result = self.new(0)
+      result = new(0)
       pairs.each { |key, val| result.put!(key, val) }
       result
     end
@@ -10,8 +10,8 @@ module Immutable
     # Returns the number of key-value pairs in the trie.
     attr_reader :size
 
-    def initialize(significant_bits, size = 0, entries = [], children = [])
-      @significant_bits = significant_bits
+    def initialize(bitshift, size = 0, entries = [], children = [])
+      @bitshift = bitshift
       @entries = entries
       @children = children
       @size = size
@@ -19,7 +19,7 @@ module Immutable
 
     # Returns <tt>true</tt> if the trie contains no key-value pairs.
     def empty?
-      size == 0
+      @size == 0
     end
 
     # Returns <tt>true</tt> if the given key is present in the trie.
@@ -29,15 +29,7 @@ module Immutable
 
     # Calls <tt>block</tt> once for each entry in the trie, passing the key-value pair as parameters.
     def each(&block)
-      # 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 }
+      @entries.each { |entry| yield entry if entry }
       @children.each do |child|
         child.each(&block) if child
       end
@@ -65,7 +57,7 @@ module Immutable
 
     # @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
+    #   key-value pair was already stored
     def put(key, value)
       index = index_for(key)
       entry = @entries[index]
@@ -74,7 +66,7 @@ module Immutable
         entries = @entries.dup
         key = key.dup.freeze if key.is_a?(String) && !key.frozen?
         entries[index] = [key, value].freeze
-        Trie.new(@significant_bits, @size + 1, entries, @children)
+        Trie.new(@bitshift, @size + 1, entries, @children)
       elsif entry[0].eql?(key)
         if entry[1].equal?(value)
           self
@@ -82,7 +74,7 @@ module Immutable
           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)
+          Trie.new(@bitshift, @size, entries, @children)
         end
       else
         child = @children[index]
@@ -94,12 +86,12 @@ module Immutable
             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)
+            Trie.new(@bitshift, 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)
+          children[index] = Trie.new(@bitshift + 5).put!(key, value)
+          Trie.new(@bitshift, @size + 1, @entries, children)
         end
       end
     end
@@ -141,14 +133,14 @@ module Immutable
             end
           else
             new_children ||= @children.dup
-            new_children[index] = Trie.new(@significant_bits + 5).put!(key, value)
+            new_children[index] = Trie.new(@bitshift + 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)
+        Trie.new(@bitshift, new_size, new_entries || @entries, new_children || @children)
       else
         self
       end
@@ -172,7 +164,7 @@ module Immutable
           @children[index] = child.put!(key, value)
           @size += child.size - old_child_size
         else
-          @children[index] = Trie.new(@significant_bits + 5).put!(key, value)
+          @children[index] = Trie.new(@bitshift + 5).put!(key, value)
           @size += 1
         end
       end
@@ -193,7 +185,7 @@ module Immutable
 
     # Returns a copy of <tt>self</tt> with the given key (and associated value) deleted. If not found, returns <tt>self</tt>.
     def delete(key)
-      find_and_delete(key) || Trie.new(@significant_bits)
+      find_and_delete(key) || Trie.new(@bitshift)
     end
 
     # Delete multiple elements from a Trie.  This is more efficient than
@@ -238,7 +230,7 @@ module Immutable
       end
 
       if new_entries || new_children
-        Trie.new(@significant_bits, new_size, new_entries || @entries, new_children || @children)
+        Trie.new(@bitshift, new_size, new_entries || @entries, new_children || @children)
       else
         self
       end
@@ -277,7 +269,7 @@ module Immutable
       end
       true
     end
-    alias :== :eql?
+    alias == eql?
 
     protected
 
@@ -297,7 +289,7 @@ module Immutable
             children = @children.dup
             children[index] = copy
             new_size = @size - (child.size - copy_size(copy))
-            return Trie.new(@significant_bits, new_size, @entries, children)
+            return Trie.new(@bitshift, new_size, @entries, children)
           end
         end
       end
@@ -318,14 +310,14 @@ module Immutable
         else
           entries[index] = nil
         end
-        Trie.new(@significant_bits, @size - 1, entries, children || @children)
+        Trie.new(@bitshift, @size - 1, entries, children || @children)
       end
     end
 
     private
 
     def index_for(key)
-      (key.hash.abs >> @significant_bits) & 31
+      (key.hash.abs >> @bitshift) & 31
     end
 
     def copy_size(copy)
@@ -334,5 +326,5 @@ module Immutable
   end
 
   # @private
-  EmptyTrie = Trie.new(0)
+  EmptyTrie = Trie.new(0).freeze
 end