hamster 1.0.0 → 1.0.1.pre.rc.1

data/lib/hamster/sorter.rb

@@ -0,0 +1,25 @@
+require "forwardable"
+require "hamster/immutable"
+require "hamster/core_ext/enumerator"
+
+module Hamster
+  class Sorter
+    include ::Enumerable
+    extend Forwardable
+    include Immutable
+
+    def initialize(collection)
+      @collection = collection
+    end
+
+    def_delegator :@collection, :each
+
+    def sort(&comparator)
+      super.to_enum.to_list
+    end
+
+    def sort_by(&transformer)
+      super.to_enum.to_list
+    end
+  end
+end

data/lib/hamster/stack.rb

@@ -0,0 +1,75 @@
+require "forwardable"
+require "hamster/immutable"
+require "hamster/list"
+
+module Hamster
+  def self.stack(*items)
+    items.reduce(EmptyStack) { |stack, item| stack.push(item) }
+  end
+
+  class Stack
+    extend Forwardable
+    include Immutable
+
+    attr_reader :list
+    def_delegator :self, :list, :to_list
+
+    def initialize
+      @list = EmptyList
+    end
+
+    def empty?
+      @list.empty?
+    end
+
+    def size
+      @list.size
+    end
+    def_delegator :self, :size, :length
+
+    def peek
+      @list.head
+    end
+    def_delegator :self, :peek, :top
+
+    def push(item)
+      transform { @list = @list.cons(item) }
+    end
+    def_delegator :self, :push, :<<
+    def_delegator :self, :push, :enqueue
+
+    def pop
+      list = @list.tail
+      if list.empty?
+        EmptyStack
+      else
+        transform { @list = list }
+      end
+    end
+    def_delegator :self, :pop, :dequeue
+
+    def clear
+      EmptyStack
+    end
+
+    def eql?(other)
+      instance_of?(other.class) && @list.eql?(other.instance_variable_get(:@list))
+    end
+    def_delegator :self, :eql?, :==
+
+    def to_a
+      @list.to_a
+    end
+    def_delegator :self, :to_a, :entries
+
+    def to_ary
+      @list.to_ary
+    end
+
+    def inspect
+      @list.inspect
+    end
+  end
+
+  EmptyStack = Hamster::Stack.new
+end

data/lib/hamster/trie.rb

@@ -1,11 +1,8 @@
+require "forwardable"
+
 module Hamster
-  # @private
   class Trie
-    def self.[](pairs)
-      result = self.new(0)
-      pairs.each { |key, val| result.put!(key, val) }
-      result
-    end
+    extend Forwardable
 
     # Returns the number of key-value pairs in the trie.
     attr_reader :size
@@ -26,156 +23,59 @@ module Hamster
     def key?(key)
       !!get(key)
     end
+    def_delegator :self, :key?, :has_key?
 
     # Calls <tt>block</tt> once for each entry in the trie, passing the key-value pair as parameters.
-    def each(&block)
+    def each
       @entries.each { |entry| yield(entry) if entry }
       @children.each do |child|
-        child.each(&block) if child
+        child.each { |entry| yield(entry) } if child
       end
       nil
     end
 
-    def reverse_each(&block)
-      @children.reverse_each do |child|
-        child.reverse_each(&block) if child
-      end
-      @entries.reverse_each { |entry| yield(entry) if entry }
-      nil
-    end
-
     def reduce(memo)
       each { |entry| memo = yield(memo, entry) }
       memo
     end
 
-    def select
-      keys_to_delete = []
-      each { |entry| keys_to_delete << entry[0] unless yield(entry) }
-      bulk_delete(keys_to_delete)
+    def filter
+      reduce(self) { |trie, entry| yield(entry) ? trie : trie.delete(entry.key) }
     end
 
-    # @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
+    # Returns a copy of <tt>self</tt> with the given value associated with the key.
     def put(key, value)
       index = index_for(key)
       entry = @entries[index]
 
       if !entry
         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)
-      elsif entry[0].eql?(key)
-        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
-        child = @children[index]
-        if child
-          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
-      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
-
-    # Returns <tt>self</tt> after overwriting the element associated with the specified key.
-    def put!(key, value)
-      index = index_for(key)
-      entry = @entries[index]
-      if !entry
-        @size += 1
-        key = key.dup.freeze if key.is_a?(String) && !key.frozen?
-        @entries[index] = [key, value].freeze
-      elsif entry[0].eql?(key)
-        key = key.dup.freeze if key.is_a?(String) && !key.frozen?
-        @entries[index] = [key, value].freeze
+        entries[index] = Entry.new(key, value)
+        self.class.new(@significant_bits, @size + 1, entries, @children)
+      elsif entry.key.eql?(key)
+        entries = @entries.dup
+        entries[index] = Entry.new(key, value)
+        self.class.new(@significant_bits, @size, entries, @children)
       else
-        child = @children[index]
+        children = @children.dup
+        child = children[index]
+        child_size = child ? child.size : 0
         if child
-          old_child_size = child.size
-          @children[index] = child.put!(key, value)
-          @size += child.size - old_child_size
+          children[index] = child.put(key, value)
         else
-          @children[index] = Trie.new(@significant_bits + 5).put!(key, value)
-          @size += 1
+          children[index] = self.class.new(@significant_bits + 5).put!(key, value)
         end
+        new_child_size = children[index].size
+        new_self_size = @size + (new_child_size - child_size)
+        self.class.new(@significant_bits, new_self_size, @entries, children)
       end
-      self
     end
 
     # Retrieves the entry corresponding to the given key. If not found, returns <tt>nil</tt>.
     def get(key)
       index = index_for(key)
       entry = @entries[index]
-      if entry && entry[0].eql?(key)
+      if entry && entry.key.eql?(key)
         entry
       else
         child = @children[index]
@@ -185,79 +85,12 @@ module Hamster
 
     # 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)
-    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
+      find_and_delete(key) || self.class.new(@significant_bits)
     end
 
     def include?(key, value)
       entry = get(key)
-      entry && value.eql?(entry[1])
-    end
-
-    def at(index)
-      @entries.each do |entry|
-        if entry
-          return entry if index == 0
-          index -= 1
-        end
-      end
-      @children.each do |child|
-        if child
-          if child.size >= index+1
-            return child.at(index)
-          else
-            index -= child.size
-          end
-        end
-      end
-      nil
+      entry && value.eql?(entry.value)
     end
 
     # Returns <tt>true</tt> if . <tt>eql?</tt> is synonymous with <tt>==</tt>
@@ -265,21 +98,29 @@ module Hamster
       return true if equal?(other)
       return false unless instance_of?(other.class) && size == other.size
       each do |entry|
-        return false unless other.include?(entry[0], entry[1])
+        return false unless other.include?(entry.key, entry.value)
       end
       true
     end
-    alias :== :eql?
+    def_delegator :self, :eql?, :==
 
     protected
 
+    # Returns <tt>self</tt> after overwriting the element associated with the specified key.
+    def put!(key, value)
+      index = index_for(key)
+      @size += 1 unless @entries[index]
+      @entries[index] = Entry.new(key, value)
+      self
+    end
+
     # Returns a replacement instance after removing the specified key.
     # If not found, returns <tt>self</tt>.
     # If empty, returns <tt>nil</tt>.
     def find_and_delete(key)
       index = index_for(key)
       entry = @entries[index]
-      if entry && entry[0].eql?(key)
+      if entry && entry.key.eql?(key)
         return delete_at(index)
       else
         child = @children[index]
@@ -289,7 +130,7 @@ module Hamster
             children = @children.dup
             children[index] = copy
             new_size = @size - (child.size - copy_size(copy))
-            return Trie.new(@significant_bits, new_size, @entries, children)
+            return self.class.new(@significant_bits, new_size, @entries, children)
           end
         end
       end
@@ -310,7 +151,7 @@ module Hamster
         else
           entries[index] = nil
         end
-        Trie.new(@significant_bits, @size - 1, entries, children || @children)
+        self.class.new(@significant_bits, @size - 1, entries, children || @children)
       end
     end
 
@@ -323,8 +164,16 @@ module Hamster
     def copy_size(copy)
       copy ? copy.size : 0
     end
+
+    class Entry
+      attr_reader :key, :value
+
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+    end
   end
 
-  # @private
   EmptyTrie = Hamster::Trie.new(0)
 end

data/lib/hamster/tuple.rb

@@ -0,0 +1,39 @@
+require "forwardable"
+require "hamster/immutable"
+
+module Hamster
+  class Tuple
+    extend Forwardable
+    include Immutable
+
+    def initialize(*items)
+      @items = items.freeze
+    end
+
+    def first
+      @items.first
+    end
+
+    def last
+      @items.last
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      instance_of?(other.class) && @items.eql?(other.instance_variable_get(:@items))
+    end
+    def_delegator :self, :eql?, :==
+
+    def to_ary
+      @items
+    end
+
+    def to_a
+      @items.dup
+    end
+
+    def inspect
+      "(#{@items.inspect[1..-2]})"
+    end
+  end
+end