hamster 0.3.3 → 0.3.4

data/History.rdoc

@@ -1,3 +1,21 @@
+=== 0.3.4 / 2010-04-29
+
+* Reduce garbage collection by keeping a singleton instance of an empty hash.
+
+* Added some VERY experimental Read-Copy-Update collections (no tests).
+
+* Slightly improve performance and greatly improve the readability of #eql?/#== methods.
+
+* Added some VERY experimental memoization for immutable objects.
+
+* Added Set#merge as an alias for Set#union.
+
+* Implemented Hash#merge (aliased as #+).
+
+=== 0.3.3 / 2010-04-09
+
+* Fixed: hash code generation had VERY poor distribution.
+
 === 0.3.1 / 2010-04-04
 
 * Fixed: Immutable not required in hamster.rb

data/lib/hamster/hash.rb

@@ -6,7 +6,7 @@ require 'hamster/trie'
 module Hamster
 
   def self.hash(pairs = {})
-    pairs.reduce(Hash.new) { |hash, pair| hash.put(pair.first, pair.last) }
+    pairs.reduce(EmptyHash) { |hash, pair| hash.put(pair.first, pair.last) }
   end
 
   class Hash
@@ -38,7 +38,7 @@ module Hamster
 
     def get(key)
       entry = @trie.get(key)
-      return entry.value if entry
+      entry.value if entry
     end
     def_delegator :self, :get, :[]
 
@@ -114,12 +114,17 @@ module Hamster
     end
     def_delegator :self, :find, :detect
 
+    def merge(other)
+      transform { @trie = other.reduce(@trie, &:put) }
+    end
+    def_delegator :self, :merge, :+
+
     def keys
       reduce(Hamster.set) { |keys, key, value| keys.add(key) }
     end
 
     def eql?(other)
-      other.is_a?(self.class) && @trie.eql?(other.instance_eval{@trie})
+      instance_of?(other.class) && @trie.eql?(other.instance_variable_get(:@trie))
     end
     def_delegator :self, :eql?, :==
 
@@ -137,4 +142,6 @@ module Hamster
 
   end
 
+  EmptyHash = Hash.new
+
 end

data/lib/hamster/immutable.rb

@@ -1,5 +1,3 @@
-require 'forwardable'
-
 module Hamster
 
   module Immutable
@@ -14,26 +12,57 @@ module Hamster
     module ClassMethods
 
       def new(*args)
-        super.freeze
+        super.immutable!
+      end
+
+      def memoize(*names)
+        include MemoizeMethods unless include?(MemoizeMethods)
+        names.each do |name|
+          original_method = "__hamster_immutable_#{name}__"
+          alias_method original_method, name
+          class_eval <<-METHOD, __FILE__, __LINE__
+            def #{name}
+              if @__hamster_immutable_memory__.instance_variable_defined?(:@#{name})
+                @__hamster_immutable_memory__.instance_variable_get(:@#{name})
+              else
+                @__hamster_immutable_memory__.instance_variable_set(:@#{name}, #{original_method})
+              end
+            end
+          METHOD
+        end
+      end
+
+    end
+
+    module MemoizeMethods
+
+      def immutable!
+        @__hamster_immutable_memory__ = Object.new
+        freeze
       end
 
     end
 
     module InstanceMethods
 
-      extend Forwardable
+      def immutable!
+        freeze
+      end
 
       def immutable?
         frozen?
       end
 
-      alias_method :__copy__, :dup
-      private :__copy__
+      alias_method :__hamster_immutable_dup__, :dup
+      private :__hamster_immutable_dup__
 
       def dup
         self
       end
-      def_delegator :self, :dup, :clone
+
+      def clone
+        self
+      end
 
       protected
 
@@ -42,7 +71,7 @@ module Hamster
       end
 
       def transform(&block)
-        __copy__.tap { |copy| copy.instance_eval(&block) }.freeze
+        __hamster_immutable_dup__.tap { |copy| copy.instance_eval(&block) }.immutable!
       end
 
     end

data/lib/hamster/list.rb

@@ -380,7 +380,7 @@ module Hamster
 
     def group_by(&block)
       return group_by { |item| item } unless block_given?
-      reduce(Hamster::Hash.new) do |hash, item|
+      reduce(EmptyHash) do |hash, item|
         key = yield(item)
         hash.put(key, (hash.get(key) || EmptyList).cons(item))
       end

data/lib/hamster/read_copy_update_hash.rb

@@ -0,0 +1,46 @@
+require 'forwardable'
+require 'thread'
+
+require 'hamster/hash'
+
+module Hamster
+
+  class ReadCopyUpdateHash
+
+    extend Forwardable
+
+    def initialize
+      @hash = EmptyHash
+      @lock = Mutex.new
+    end
+
+    def put(key, value)
+      @lock.synchronize {
+        original_value = @hash.get(key)
+        @hash = @hash.put(key, value)
+        original_value
+      }
+    end
+
+    def delete(key)
+      @lock.synchronize {
+        original_value = @hash.get(key)
+        @hash = @hash.delete(key)
+        original_value
+      }
+    end
+
+    def eql?(other)
+      instance_of?(other.class) && @hash.eql?(other.instance_variable_get(:@hash))
+    end
+    def_delegator :self, :eql?, :==
+
+    private
+
+    def method_missing(name, *args, &block)
+      @hash.send(name, *args, &block)
+    end
+
+  end
+
+end

data/lib/hamster/read_copy_update_set.rb

@@ -0,0 +1,40 @@
+require 'forwardable'
+require 'thread'
+
+require 'hamster/set'
+
+module Hamster
+
+  class ReadCopyUpdateSet
+
+    extend Forwardable
+
+    def initialize
+      @set = EmptySet
+      @lock = Mutex.new
+    end
+
+    def add(value)
+      @lock.synchronize { @set = @set.add(value) }
+      self
+    end
+
+    def delete(value)
+      @lock.synchronize { @set = @set.delete(value) }
+      self
+    end
+
+    def eql?(other)
+      instance_of?(other.class) && @set.eql?(other.instance_variable_get(:@set))
+    end
+    def_delegator :self, :eql?, :==
+
+    private
+
+    def method_missing(name, *args, &block)
+      @set.send(name, *args, &block)
+    end
+
+  end
+
+end

data/lib/hamster/read_copy_update_stack.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+require 'thread'
+
+require 'hamster/set'
+
+module Hamster
+
+  class ReadCopyUpdateStack
+
+    extend Forwardable
+
+    def initialize
+      @stack = EmptyStack
+      @lock = Mutex.new
+    end
+
+    def push(value)
+      @lock.synchronize { @stack = @stack.push(value) }
+      self
+    end
+
+    def pop
+      @lock.synchronize {
+        top_value = @stack.peek
+        @stack = @stack.pop
+        top_value
+      }
+    end
+
+    def eql?(other)
+      instance_of?(other.class) && @stack.eql?(other.instance_variable_get(:@stack))
+    end
+    def_delegator :self, :eql?, :==
+
+    private
+
+    def method_missing(name, *args, &block)
+      @stack.send(name, *args, &block)
+    end
+
+  end
+
+end

data/lib/hamster/set.rb

@@ -191,6 +191,7 @@ module Hamster
     end
     def_delegator :self, :union, :|
     def_delegator :self, :union, :+
+    def_delegator :self, :union, :merge
 
     def intersection(other)
       trie = @trie.filter { |entry| other.include?(entry.key) }
@@ -233,7 +234,7 @@ module Hamster
 
     def group_by(&block)
       return group_by { |item| item } unless block_given?
-      reduce(Hamster::Hash.new) do |hash, item|
+      reduce(EmptyHash) do |hash, item|
         key = yield(item)
         hash.put(key, (hash.get(key) || EmptySet).add(item))
       end
@@ -244,7 +245,7 @@ module Hamster
     end
 
     def eql?(other)
-      other.is_a?(self.class) && @trie.eql?(other.instance_eval{@trie})
+      instance_of?(other.class) && @trie.eql?(other.instance_variable_get(:@trie))
     end
     def_delegator :self, :eql?, :==
 

data/lib/hamster/stack.rb

@@ -51,9 +51,7 @@ module Hamster
     end
 
     def eql?(other)
-      return true if other.equal?(self)
-      return false unless other.class.equal?(self.class)
-      @list.eql?(other.instance_eval{@list})
+      instance_of?(other.class) && @list.eql?(other.instance_variable_get(:@list))
     end
     def_delegator :self, :eql?, :==
 

data/lib/hamster/trie.rb

@@ -91,8 +91,8 @@ module Hamster
 
     # Returns <tt>true</tt> if . <tt>eql?</tt> is synonymous with <tt>==</tt>
     def eql?(other)
-      # return true if other.equal?(self)
-      return false unless other.is_a?(self.class) && other.size == size
+      return true if equal?(other)
+      return false unless instance_of?(other.class) && size == other.size
       each do |entry|
         return false unless other.include?(entry.key, entry.value)
       end

data/lib/hamster/tuple.rb

@@ -24,8 +24,7 @@ module Hamster
 
     def eql?(other)
       return true if other.equal?(self)
-      return false unless other.class.equal?(self.class)
-      @items.eql?(other.instance_eval{@items})
+      instance_of?(other.class) && @items.eql?(other.instance_variable_get(:@items))
     end
     def_delegator :self, :eql?, :==
 

data/lib/hamster/version.rb

@@ -1,5 +1,5 @@
 module Hamster
 
-  VERSION = "0.3.3".freeze
+  VERSION = "0.3.4".freeze
 
 end

data/spec/hamster/hash/merge_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+require 'hamster/hash'
+
+describe Hamster::Hash do
+
+  [:merge, :+].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [[], [], []],
+        [["A" => "aye"], [], ["A" => "aye"]],
+        [["A" => "aye"], ["A" => "bee"], ["A" => "bee"]],
+        [["A" => "aye"], ["B" => "bee"], ["A" => "aye", "B" => "bee"]],
+      ].each do |a, b, expected|
+
+        describe "for #{a.inspect} and #{b.inspect}" do
+
+          before do
+            @result = Hamster.hash(*a).send(method, Hamster.hash(*b))
+          end
+
+          it "returns #{expected.inspect}"  do
+            @result.should == Hamster.hash(*expected)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/immutable/memoize_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+require 'hamster/immutable'
+
+describe Hamster::Immutable do
+
+  describe "#memoize" do
+
+    class Fixture
+      include Hamster::Immutable
+
+      def initialize(&block)
+        @block = block
+      end
+
+      def call
+        @block.call
+      end
+      memoize :call
+
+      def copy
+        transform {}
+      end
+
+    end
+
+    before do
+      @count = 0
+      @fixture = Fixture.new { @count += 1 }
+      @fixture.call
+    end
+
+    it "should still freezes be immutable" do
+      @fixture.should be_immutable
+    end
+
+    describe "when called multiple times" do
+
+      before do
+        @fixture.call
+      end
+
+      it "a memoized method will only be evaluated once" do
+        @count.should == 1
+      end
+
+    end
+
+    describe "when making a copy" do
+
+      before do
+        @copy = @fixture.copy
+        @copy.call
+      end
+
+      it "should clear all memory" do
+        @count.should == 2
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/set/union_spec.rb

@@ -4,7 +4,7 @@ require 'hamster/set'
 
 describe Hamster::Set do
 
-  [:union, :|, :+].each do |method|
+  [:union, :|, :+, :merge].each do |method|
 
     describe "##{method}" do
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 3
-  version: 0.3.3
+  - 4
+  version: 0.3.4
 platform: ruby
 authors: 
 - Simon Harris
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-09 00:00:00 +10:00
+date: 2010-04-29 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -62,6 +62,9 @@ files:
 - lib/hamster/hash.rb
 - lib/hamster/immutable.rb
 - lib/hamster/list.rb
+- lib/hamster/read_copy_update_hash.rb
+- lib/hamster/read_copy_update_set.rb
+- lib/hamster/read_copy_update_stack.rb
 - lib/hamster/set.rb
 - lib/hamster/sorter.rb
 - lib/hamster/stack.rb
@@ -91,6 +94,7 @@ files:
 - spec/hamster/hash/inspect_spec.rb
 - spec/hamster/hash/keys_spec.rb
 - spec/hamster/hash/map_spec.rb
+- spec/hamster/hash/merge_spec.rb
 - spec/hamster/hash/none_spec.rb
 - spec/hamster/hash/put_spec.rb
 - spec/hamster/hash/reduce_spec.rb
@@ -99,6 +103,7 @@ files:
 - spec/hamster/hash/uniq_spec.rb
 - spec/hamster/immutable/copying_spec.rb
 - spec/hamster/immutable/immutable_spec.rb
+- spec/hamster/immutable/memoize_spec.rb
 - spec/hamster/immutable/new_spec.rb
 - spec/hamster/immutable/transform_spec.rb
 - spec/hamster/immutable/transform_unless_spec.rb