hamster 1.0.1.pre.rc.1 → 1.0.1.pre.rc2

data/lib/hamster/stack.rb

@@ -37,6 +37,8 @@ module Hamster
     end
     def_delegator :self, :push, :<<
     def_delegator :self, :push, :enqueue
+    def_delegator :self, :push, :conj
+    def_delegator :self, :push, :conjoin
 
     def pop
       list = @list.tail

data/lib/hamster/trie.rb

@@ -1,8 +1,10 @@
-require "forwardable"
-
 module Hamster
   class Trie
-    extend Forwardable
+    def self.[](pairs)
+      result = self.new(0)
+      pairs.each { |key, val| result.send(:put!, key, val) }
+      result
+    end
 
     # Returns the number of key-value pairs in the trie.
     attr_reader :size
@@ -23,7 +25,6 @@ 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
@@ -50,12 +51,14 @@ module Hamster
 
       if !entry
         entries = @entries.dup
+        key = key.dup.freeze if key.is_a?(String)
         entries[index] = Entry.new(key, value)
-        self.class.new(@significant_bits, @size + 1, entries, @children)
+        Trie.new(@significant_bits, @size + 1, entries, @children)
       elsif entry.key.eql?(key)
         entries = @entries.dup
+        key = key.dup.freeze if key.is_a?(String)
         entries[index] = Entry.new(key, value)
-        self.class.new(@significant_bits, @size, entries, @children)
+        Trie.new(@significant_bits, @size, entries, @children)
       else
         children = @children.dup
         child = children[index]
@@ -63,11 +66,11 @@ module Hamster
         if child
           children[index] = child.put(key, value)
         else
-          children[index] = self.class.new(@significant_bits + 5).put!(key, value)
+          children[index] = Trie.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)
+        Trie.new(@significant_bits, new_self_size, @entries, children)
       end
     end
 
@@ -85,7 +88,7 @@ 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) || self.class.new(@significant_bits)
+      find_and_delete(key) || Trie.new(@significant_bits)
     end
 
     def include?(key, value)
@@ -102,15 +105,32 @@ module Hamster
       end
       true
     end
-    def_delegator :self, :eql?, :==
+    alias :== :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)
+      entry = @entries[index]
+      if !entry
+        @size += 1
+        key = key.dup.freeze if key.is_a?(String)
+        @entries[index] = Entry.new(key, value)
+      elsif entry.key.eql?(key)
+        key = key.dup.freeze if key.is_a?(String)
+        @entries[index] = Entry.new(key, value)
+      else
+        child = @children[index]
+        if child
+          old_child_size = child.size
+          @children[index] = child.put!(key, value)
+          @size += child.size - old_child_size
+        else
+          @children[index] = Trie.new(@significant_bits + 5).put!(key, value)
+          @size += 1
+        end
+      end
       self
     end
 
@@ -130,7 +150,7 @@ module Hamster
             children = @children.dup
             children[index] = copy
             new_size = @size - (child.size - copy_size(copy))
-            return self.class.new(@significant_bits, new_size, @entries, children)
+            return Trie.new(@significant_bits, new_size, @entries, children)
           end
         end
       end
@@ -151,7 +171,7 @@ module Hamster
         else
           entries[index] = nil
         end
-        self.class.new(@significant_bits, @size - 1, entries, children || @children)
+        Trie.new(@significant_bits, @size - 1, entries, children || @children)
       end
     end
 

data/lib/hamster/tuple.rb

@@ -1,39 +1,24 @@
-require "forwardable"
 require "hamster/immutable"
 
 module Hamster
-  class Tuple
-    extend Forwardable
+  def self.tuple(*items)
+    Hamster::Tuple.new(*items)
+  end
+  class Tuple < Array
     include Immutable
 
     def initialize(*items)
-      @items = items.freeze
-    end
-
-    def first
-      @items.first
-    end
-
-    def last
-      @items.last
+      super(items)
     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
+      other.is_a?(Tuple) && super
     end
 
     def inspect
-      "(#{@items.inspect[1..-2]})"
+      "(#{super[1..-2]})"
     end
+
+    undef :<<, :[]=, :collect!, :compact!, :delete, :delete_at, :delete_if, :flatten!, :map!, :reject!, :reverse!, :rotate!, :select!, :shuffle!, :slice!, :sort!, :sort_by!, :uniq!
   end
 end

data/lib/hamster/vector.rb

@@ -5,7 +5,7 @@ require "hamster/enumerable"
 
 module Hamster
   def self.vector(*items)
-    items.reduce(EmptyVector) { |vector, item| vector.add(item) }
+    Vector.new(items)
   end
 
   class Vector
@@ -20,10 +20,30 @@ module Hamster
     attr_reader :size
     def_delegator :self, :size, :length
 
-    def initialize
+    class << self
+      alias :alloc :new
+
+      def new(items=[])
+        items.empty? ? empty : alloc(items)
+      end
+
+      def [](*items)
+        new(items)
+      end
+
+      def empty
+        @empty ||= self.alloc
+      end
+    end
+
+    def initialize(items=[])
+      @root   = items
+      @size   = items.size
       @levels = 0
-      @root = []
-      @size = 0
+      while @root.size > 32
+        @root = @root.each_slice(32).to_a
+        @levels += 1
+      end
     end
 
     def empty?
@@ -48,6 +68,8 @@ module Hamster
     end
     def_delegator :self, :add, :<<
     def_delegator :self, :add, :cons
+    def_delegator :self, :add, :conj
+    def_delegator :self, :add, :conjoin
 
     # def delete(index)
     # end
@@ -79,13 +101,13 @@ module Hamster
 
     def map(&block)
       return self unless block_given?
-      reduce(EmptyVector) { |vector, item| vector.add(yield(item)) }
+      reduce(self.class.empty) { |vector, item| vector.add(yield(item)) }
     end
     def_delegator :self, :map, :collect
 
     def filter
       return self unless block_given?
-      reduce(EmptyVector) { |vector, item| yield(item) ? vector.add(item) : vector }
+      reduce(self.class.empty) { |vector, item| yield(item) ? vector.add(item) : vector }
     end
 
     def clear
@@ -143,7 +165,7 @@ module Hamster
     end
 
     def full?
-      (@size >> root_index_bits) > 0
+      (@size >> root_index_bits) > 31
     end
 
     def root_index_bits

data/lib/hamster/version.rb

@@ -1,3 +1,3 @@
 module Hamster
-  VERSION = "1.0.1-rc.1"
+  VERSION = "1.0.1-rc2"
 end

data/spec/hamster/core_ext/array_spec.rb

@@ -1,20 +1,14 @@
 require "spec_helper"
-
 require "hamster/core_ext/enumerable"
 
 describe Array do
+  let(:array) { %w[A B C] }
 
   describe "#to_list" do
+    let(:to_list) { array.to_list }
 
-    before do
-      array = %w[A B C]
-      @list = array.to_list
-    end
-
-    it "returns an equivalent list" do
-      @list.should == Hamster.list("A", "B", "C")
+    it "should be an equivalent hamster list" do
+      expect(to_list).to eq(Hamster.list("A", "B", "C"))
     end
-
   end
-
 end

data/spec/hamster/core_ext/enumerable_spec.rb

@@ -13,6 +13,7 @@ describe Enumerable do
       @values.each(&block)
     end
   end
+
   let(:enumerable) { TestEnumerable.new("A", "B", "C") }
 
   describe "#to_list" do

data/spec/hamster/experimental/mutable_set/add_qm_spec.rb

@@ -3,45 +3,37 @@ require "spec_helper"
 require "hamster/experimental/mutable_set"
 
 describe Hamster::MutableSet do
+  let(:mutable) { Hamster.mutable_set(*values) }
 
   describe "#add?" do
+    let(:values) { %w[A B C] }
+    let(:add?) { mutable.add?(value) }
 
-    before do
-      @set = Hamster.mutable_set("A", "B", "C")
-    end
-
-    describe "with a unique value" do
-
-      before do
-        @result = @set.add?("D")
-      end
+    context "with a unique value" do
+      let(:value) { "D" }
 
       it "returns true" do
-        @result.should == true
+        expect(add?).to be true
       end
 
       it "modifies the set to include the new value" do
-        @set.should == Hamster.mutable_set("A", "B", "C", "D")
+        add?
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C", "D"))
       end
 
     end
 
-    describe "with a duplicate value" do
+    context "with a duplicate value" do
+      let(:value) { "C" }
 
-      before do
-        @result = @set.add?("C")
+      it "returns false" do
+        expect(add?).to be(false)
       end
 
       it "preserves the original values" do
-        @set.should == Hamster.mutable_set("A", "B", "C")
+        add?
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
       end
-
-      it "returns false" do
-        @result.should == false
-      end
-
     end
-
   end
-
 end

data/spec/hamster/experimental/mutable_set/add_spec.rb

@@ -1,51 +1,37 @@
 require "spec_helper"
-
 require "hamster/experimental/mutable_set"
 
 describe Hamster::MutableSet do
+  let(:mutable) { Hamster.mutable_set(*values) }
 
-  [:add, :<<].each do |method|
+  describe "#add" do
+    let(:values) { %w[A B C] }
+    let(:add) { mutable.add(value) }
 
-    describe "##{method}" do
+    context "with a unique value" do
+      let(:value) { "D" }
 
-      before do
-        @set = Hamster.mutable_set("A", "B", "C")
+      it "returns self" do
+        expect(add).to eq(mutable)
       end
 
-      describe "with a unique value" do
-
-        before do
-          @result = @set.send(method, "D")
-        end
-
-        it "returns self" do
-          @result.should equal(@set)
-        end
-
-        it "modifies the set to include the new value" do
-          @set.should == Hamster.mutable_set("A", "B", "C", "D")
-        end
-
+      it "modifies the original set to include new value" do
+        add
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C", "D"))
       end
+    end
 
-      describe "with a duplicate value" do
-
-        before do
-          @result = @set.send(method, "C")
-        end
-
-        it "preserves the original values" do
-          @set.should == Hamster.mutable_set("A", "B", "C")
-        end
-
-        it "returns self" do
-          @result.should equal(@set)
-        end
+    context "with a duplicate value" do
+      let(:value) { "C" }
 
+      it "returns self" do
+        expect(add).to eq(mutable)
       end
 
+      it "preserves the original values" do
+        add
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+      end
     end
-
   end
-
 end

data/spec/hamster/experimental/mutable_set/delete_qm_spec.rb

@@ -1,47 +1,38 @@
 require "spec_helper"
-
 require "hamster/experimental/mutable_set"
 
-describe Hamster::Set do
+describe Hamster::MutableSet do
+  let(:mutable) { Hamster.mutable_set(*values) }
 
   describe "#delete?" do
+    let(:values) { %w[A B C] }
+    let(:delete?) { mutable.delete?(value) }
 
-    before do
-      @set = Hamster.mutable_set("A", "B", "C")
-    end
-
-    describe "with an existing value" do
 
-      before do
-        @result = @set.delete?("B")
-      end
+    context "with an existing value" do
+      let(:value) { "B" }
 
       it "returns true" do
-        @result.should == true
+        expect(delete?).to be(true)
       end
 
       it "modifies the set to remove the value" do
-        @set.should == Hamster.mutable_set("A", "C")
+        delete?
+        expect(mutable).to eq(Hamster.mutable_set("A", "C"))
       end
-
     end
 
-    describe "with a non-existing value" do
+    context "with a non-existing value" do
+      let(:value) { "D" }
 
-      before do
-        @result = @set.delete?("D")
+      it "returns false" do
+        expect(delete?).to be(false)
       end
 
       it "preserves the original values" do
-        @set.should == Hamster.mutable_set("A", "B", "C")
+        delete?
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
       end
-
-      it "returns false" do
-        @result.should == false
-      end
-
     end
-
   end
-
 end