hamster 0.1.21 → 0.1.22

data/History.rdoc

@@ -1,3 +1,29 @@
+=== 0.1.22 / 2010-01-10
+
+* Implement List#union (aliased as #|).
+
+* Implement List#uniq (aliased as #nub).
+
+* Implement List#intersperse.
+
+* Alias #include? as #elem?
+
+* Implement Stack#to_list.
+
+* Implement Stack#to_a.
+
+* Implement Set#join.
+
+* Implement Set#count.
+
+* Implement List#count.
+
+* Alias #include? as #contains?
+
+* #each now returns nil if you specify a block.
+
+* Implement Set#find (aliased as #detect).
+
 === 0.1.21 / 2010-01-08
 
 * Implement List#sort. (Very, VERY inefficient implementation!)

data/lib/hamster/hash.rb

@@ -54,7 +54,6 @@ module Hamster
     def each
       return self unless block_given?
       @trie.each { |entry| yield(entry.key, entry.value) }
-      self
     end
 
     def map

data/lib/hamster/list.rb

@@ -1,5 +1,7 @@
 require 'monitor'
 
+require 'hamster/set'
+
 module Hamster
 
   class << self
@@ -127,10 +129,11 @@ module Hamster
     end
 
     def include?(object)
-      each { |item| return true if object == item }
-      false
+      any? { |item| item == object }
     end
     alias_method :member?, :include?
+    alias_method :contains?, :include?
+    alias_method :elem?, :include?
 
     def any?
       return any? { |item| item } unless block_given?
@@ -222,12 +225,19 @@ module Hamster
       span { |item| !yield(item) }
     end
 
+    def count(&block)
+      return length unless block_given?
+      count = 0
+      each { |item| count += 1 if yield(item) }
+      count
+    end
+
     def clear
       EmptyList
     end
 
-    def sort
-      sort_by { |item| item }
+    def sort(&block)
+      Hamster.list(*to_a.sort(&block))
     end
 
     def sort_by(&block)
@@ -235,9 +245,30 @@ module Hamster
       Hamster.list(*to_a.sort_by(&block))
     end
 
-    def join(sep = nil)
-      to_a.join(sep)
+    def join(sep = "")
+      sep = sep.to_s
+      tail.reduce(head.to_s) { |string, item| string << sep << item.to_s }
+    end
+
+    def intersperse(sep)
+      return self if tail.empty?
+      Stream.new(head) { Stream.new(sep) { tail.intersperse(sep) } }
+    end
+
+    def uniq(items = Set.new)
+      list = self
+      while !list.empty? && items.include?(list.head)
+        list = list.tail
+      end
+      return list if list.empty?
+      Stream.new(list.head) { list.tail.uniq(items.add(list.head)) }
+    end
+    alias_method :nub, :uniq
+
+    def union(other)
+      self.append(other).uniq
     end
+    alias_method :|, :union
 
     def eql?(other)
       return false unless other.is_a?(List)

data/lib/hamster/set.rb

@@ -27,6 +27,8 @@ module Hamster
       @trie.has_key?(item)
     end
     alias_method :member?, :include?
+    alias_method :contains?, :include?
+    alias_method :elem?, :include?
 
     def add(item)
       if include?(item)
@@ -49,7 +51,6 @@ module Hamster
     def each
       return self unless block_given?
       @trie.each { |entry| yield(entry.key) }
-      self
     end
 
     def map
@@ -88,52 +89,65 @@ module Hamster
     alias_method :delete_if, :reject
 
     def any?
-      if block_given?
-        each { |item| return true if yield(item) }
-      else
-        each { |item| return true if item }
-      end
+      return any? { |item| item } unless block_given?
+      each { |item| return true if yield(item) }
       false
     end
     alias_method :exist?, :any?
     alias_method :exists?, :any?
 
     def all?
-      if block_given?
-        each { |item| return false unless yield(item) }
-      else
-        each { |item| return false unless item }
-      end
+      return all? { |item| item } unless block_given?
+      each { |item| return false unless yield(item) }
       true
     end
 
     def none?
-      if block_given?
-        each { |item| return false if yield(item) }
-      else
-        each { |item| return false if item }
-      end
+      return none? { |item| item } unless block_given?
+      each { |item| return false if yield(item) }
       true
     end
 
+    def find
+      return nil unless block_given?
+      each { |item| return item if yield(item) }
+      nil
+    end
+    alias_method :detect, :find
+
+    def partition(&block)
+      return self unless block_given?
+      Stream.new(filter(&block)) { Sequence.new(reject(&block)) }
+    end
+
     def grep(pattern, &block)
       filter { |item| pattern === item }.map(&block)
     end
 
+    def count(&block)
+      return length unless block_given?
+      count = 0
+      each { |item| count += 1 if yield(item) }
+      count
+    end
+
     def head
-      each { |item| return item }
-      nil
+      find { true }
     end
     alias_method :first, :head
 
-    def sort
-      to_list.sort
+    def sort(&block)
+      to_list.sort(&block)
     end
 
     def sort_by(&block)
       to_list.sort_by(&block)
     end
 
+    def join(sep = nil)
+      to_a.join(sep)
+    end
+
     def eql?(other)
       other.is_a?(self.class) && @trie.eql?(other.instance_eval{@trie})
     end

data/lib/hamster/stack.rb

@@ -55,6 +55,15 @@ module Hamster
     end
     alias_method :clone, :dup
 
+    def to_a
+      @list.to_a
+    end
+    alias_method :entries, :to_a
+
+    def to_list
+      @list
+    end
+
     def inspect
       @list.inspect
     end

data/lib/hamster/trie.rb

@@ -31,6 +31,7 @@ module Hamster
       @children.each do |child|
         child.each { |entry| yield(entry) } if child
       end
+      nil
     end
 
     def reduce(memo)

data/lib/hamster/version.rb

@@ -1,5 +1,5 @@
 module Hamster
 
-  VERSION = "0.1.21".freeze
+  VERSION = "0.1.22".freeze
 
 end

data/spec/hamster/hash/each_spec.rb

@@ -12,8 +12,8 @@ describe Hamster::Hash do
 
     describe "with a block (internal iteration)" do
 
-      it "returns self" do
-        @hash.each {}.should equal(@hash)
+      it "returns nil" do
+        @hash.each {}.should be_nil
       end
 
       it "yields all key/value pairs" do

data/spec/hamster/list/chunk_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'hamster/list'
+
+describe Hamster::List do
+
+  describe "#chunk" do
+
+    [
+      [[], []],
+      [["A"], [Hamster.list("A")]],
+      [["A", "B", "C"], [Hamster.list("A", "B"), Hamster.list("C")]],
+    ].each do |values, expected|
+
+      describe "on #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+          pending do
+            @result = @original.chunk(2)
+          end
+        end
+
+        it "preserves the original" do
+          @original.should == Hamster.list(*values)
+        end
+
+        it "returns #{expected.inspect}" do
+          @result.should == Hamster.list(*expected)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/list/{sort_by_spec.rb → count_spec.rb}

@@ -4,7 +4,7 @@ require 'hamster/list'
 
 describe Hamster::List do
 
-  describe "#sort_by" do
+  describe "#count" do
 
     describe "doesn't run out of stack space on a really big" do
 
@@ -17,15 +17,18 @@ describe Hamster::List do
       end
 
       after do
-        @list.sort_by { |item| item }
+        @list.count { true }
       end
 
     end
 
     [
-      [[], []],
-      [["A"], ["A"]],
-      [["Ichi", "Ni", "San"], ["Ni", "San", "Ichi"]],
+      [[], 0],
+      [[1], 1],
+      [[1, 2], 1],
+      [[1, 2, 3], 2],
+      [[1, 2, 3, 4], 2],
+      [[1, 2, 3, 4, 5], 3],
     ].each do |values, expected|
 
       describe "on #{values.inspect}" do
@@ -37,15 +40,11 @@ describe Hamster::List do
         describe "with a block" do
 
           before do
-            @result = @original.sort_by { |item| item.length }
-          end
-
-          it "preserves the original" do
-            @original.should == Hamster.list(*values)
+            @result = @original.count(&:odd?)
           end
 
           it "returns #{expected.inspect}" do
-            @result.should == Hamster.list(*expected)
+            @result.should == expected
           end
 
         end
@@ -53,15 +52,11 @@ describe Hamster::List do
         describe "without a block" do
 
           before do
-            @result = @original.sort_by
-          end
-
-          it "preserves the original" do
-            @original.should == Hamster.list(*values)
+            @result = @original.count
           end
 
-          it "returns #{expected.sort.inspect}" do
-            @result.should == Hamster.list(*expected.sort)
+          it "returns length" do
+            @result.should == @original.length
           end
 
         end

data/spec/hamster/list/find_spec.rb

@@ -45,7 +45,7 @@ describe Hamster::List do
           describe "with a block" do
 
             it "returns #{expected.inspect}" do
-              @list.send(method) { |x| x == item  }.should == expected
+              @list.send(method) { |x| x == item }.should == expected
             end
 
           end

data/spec/hamster/list/include_spec.rb

@@ -4,7 +4,7 @@ require 'hamster/list'
 
 describe Hamster::List do
 
-  [:include?, :member?].each do |method|
+  [:include?, :member?, :contains?, :elem?].each do |method|
 
     describe "##{method}" do
 

data/spec/hamster/{set/sort_spec.rb → list/init_spec.rb}

@@ -1,27 +1,28 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-require 'hamster/set'
 require 'hamster/list'
 
-describe Hamster::Set do
+describe Hamster::List do
 
-  describe "#sort" do
+  describe "#init" do
 
     [
       [[], []],
-      [["A"], ["A"]],
-      [["C", "A", "B"], ["A", "B", "C"]],
+      [["A"], []],
+      [["A", "B", "C"], ["A", "B"]],
     ].each do |values, expected|
 
       describe "on #{values.inspect}" do
 
         before do
-          @original = Hamster.set(*values)
-          @result = @original.sort
+          @original = Hamster.list(*values)
+          pending do
+            @result = @original.init
+          end
         end
 
         it "preserves the original" do
-          @original.should == Hamster.set(*values)
+          @original.should == Hamster.list(*values)
         end
 
         it "returns #{expected.inspect}" do

data/spec/hamster/list/{sort_spec.rb → intersperse_spec.rb}

@@ -4,7 +4,7 @@ require 'hamster/list'
 
 describe Hamster::List do
 
-  describe "#sort" do
+  describe "#intersperse" do
 
     describe "doesn't run out of stack space on a really big" do
 
@@ -17,7 +17,7 @@ describe Hamster::List do
       end
 
       after do
-        @list.sort
+        @list.intersperse(":")
       end
 
     end
@@ -25,14 +25,14 @@ describe Hamster::List do
     [
       [[], []],
       [["A"], ["A"]],
-      [["C", "A", "B"], ["A", "B", "C"]],
+      [["A", "B", "C"], ["A", "|", "B", "|", "C"]]
     ].each do |values, expected|
 
       describe "on #{values.inspect}" do
 
         before do
           @original = Hamster.list(*values)
-          @result = @original.sort
+          @result = @original.intersperse("|")
         end
 
         it "preserves the original" do