hamster 0.1.13 → 0.1.14

data/History.rdoc

@@ -1,3 +1,17 @@
+=== 0.1.14 / 2009-12-14
+
+* List#reduce supports optional initial value.
+
+* Implemented List#to_ary for implicit conversion to arrays and call parameters.
+
+* Implemented Set#to_a.
+
+* Alias #filter as #find_all.
+
+* Alias #reject as #delete_if.
+
+* Alias #reduce as #fold.
+
 === 0.1.13 / 2009-12-10
 
 * Stack now fully functional

data/README.rdoc

@@ -120,7 +120,7 @@ Lists are, where possible, lazy. That is, they try to defer processing items unt
     true
   end
 
-The following code will only call <tt>#prime?</tt> as many times as necessary to generate the first 3 prime numbers between 10000 and 1000000:
+The following code will only call <tt>prime?</tt> as many times as necessary to generate the first 3 prime numbers between 10000 and 1000000:
 
   Hamster.interval(10000, 1000000).filter { |i| prime?(i) }.take(3)    # => 0.0009s
 
@@ -142,6 +142,6 @@ Besides <tt>Hamster.list</tt> there is <tt>Hamster.interval(from, to)</tt> and <
 
 Hamster started out as a spike to prove a point and has since morphed into something I actually use. My primary concern has been to round out the functionality with good test coverage and clean, readable code.
 
-Performance is pretty good--especially with lazy lists--but there are some things which need to be converted from recursive to iterative due to a lack of Tail-Call-Optimisation in Ruby. It's on the list ;-)
+Performance is pretty good--especially with lazy lists--but there are some things which unfortunately had to be converted from recursive to iterative due to a lack of Tail-Call-Optimisation in Ruby, making them a little less readable than I would otherwise have preferred.
 
 Documentation is sparse but I've tried as best I can to write specs that reads as documentation. I've also tried to alias methods as their <tt>Enumerable</tt> equivalents where possible to make it easier for people to migrate code.

data/lib/hamster/hash.rb

@@ -51,13 +51,13 @@ module Hamster
     end
 
     def each
-      block_given? or return self
+      return self unless block_given?
       @trie.each { |entry| yield(entry.key, entry.value) }
       self
     end
 
     def map
-      block_given? or return self
+      return self unless block_given?
       if empty?
         self
       else
@@ -67,13 +67,14 @@ module Hamster
     alias_method :collect, :map
 
     def reduce(memo)
-      block_given? or return memo
+      return memo unless block_given?
       @trie.reduce(memo) { |memo, entry| yield(memo, entry.key, entry.value) }
     end
     alias_method :inject, :reduce
+    alias_method :fold, :reduce
 
     def filter
-      block_given? or return self
+      return self unless block_given?
       trie = @trie.filter { |entry| yield(entry.key, entry.value) }
       if !trie.equal?(@trie)
         self.class.new(trie)
@@ -82,17 +83,19 @@ module Hamster
       end
     end
     alias_method :select, :filter
+    alias_method :find_all, :filter
 
     def reject
-      block_given? or return self
+      return self unless block_given?
       select { |key, value| !yield(key, value) }
     end
+    alias_method :delete_if, :reject
 
     def any?
       if block_given?
         each { |key, value| return true if yield(key, value) }
       else
-        each { |pair| return true if pair }
+        return !empty?
       end
       false
     end
@@ -102,8 +105,6 @@ module Hamster
     def all?
       if block_given?
         each { |key, value| return false unless yield(key, value) }
-      else
-        each { |pair| return false unless pair }
       end
       true
     end
@@ -112,7 +113,7 @@ module Hamster
       if block_given?
         each { |key, value| return false if yield(key, value) }
       else
-        each { |pair| return false if pair }
+        return empty?
       end
       true
     end

data/lib/hamster/list.rb

@@ -1,5 +1,7 @@
 module Hamster
 
+  Undefined = Object.new
+
   class << self
 
     def list(*items)
@@ -7,7 +9,7 @@ module Hamster
     end
 
     def stream(&block)
-      block_given? or return EmptyList
+      return EmptyList unless block_given?
       Stream.new(yield) { stream(&block) }
     end
 
@@ -29,7 +31,7 @@ module Hamster
     end
 
     def size
-      tail.size + 1
+      reduce(0) { |memo, item| memo + 1 }
     end
     alias_method :length, :size
 
@@ -38,46 +40,56 @@ module Hamster
     end
     alias_method :>>, :cons
 
-    def each(&block)
-      block_given? or return self
-      yield(head)
-      tail.each(&block)
+    def each
+      return self unless block_given?
+      list = self
+      while !list.empty?
+        yield(list.head)
+        list = list.tail
+      end
       nil
     end
 
     def map(&block)
-      block_given? or return self
+      return self unless block_given?
       Stream.new(yield(head)) { tail.map(&block) }
     end
     alias_method :collect, :map
 
-    def reduce(memo, &block)
-      block_given? or return memo
-      tail.reduce(yield(memo, head), &block)
+    def reduce(memo = Undefined, &block)
+      return tail.reduce(head, &block) if memo.equal?(Undefined)
+      return memo unless block_given?
+      each { |item| memo = yield(memo, item)  }
+      memo
     end
     alias_method :inject, :reduce
+    alias_method :fold, :reduce
 
     def filter(&block)
-      block_given? or return self
-      if yield(head)
-        Stream.new(head) { tail.filter(&block) }
-      else
-        tail.filter(&block)
+      return self unless block_given?
+      list = self
+      while !yield(list.head)
+        list = list.tail
+        return list if list.empty?
       end
+      Stream.new(list.head) { list.tail.filter(&block) }
     end
     alias_method :select, :filter
+    alias_method :find_all, :filter
 
     def reject(&block)
-      block_given? or return self
-      if yield(head)
-        tail.reject(&block)
-      else
-        Stream.new(head) { tail.reject(&block) }
+      return self unless block_given?
+      list = self
+      while yield(list.head)
+        list = list.tail
+        return list if list.empty?
       end
+      Stream.new(list.head) { list.tail.reject(&block) }
     end
+    alias_method :delete_if, :reject
 
     def take_while(&block)
-      block_given? or return self
+      return self unless block_given?
       if yield(head)
         Stream.new(head) { tail.take_while(&block) }
       else
@@ -85,13 +97,13 @@ module Hamster
       end
     end
 
-    def drop_while(&block)
-      block_given? or return self
-      if yield(head)
-        tail.drop_while(&block)
-      else
-        self
+    def drop_while
+      return self unless block_given?
+      list = self
+      while !list.empty? && yield(list.head)
+        list = list.tail
       end
+      list
     end
 
     def take(number)
@@ -103,22 +115,67 @@ module Hamster
     end
 
     def drop(number)
-      if number > 0
-        tail.drop(number - 1)
-      else
-        self
+      list = self
+      while !list.empty? && number > 0
+        number -= 1
+        list = list.tail
       end
+      list
     end
 
-    def include?(item)
-      item == head || tail.include?(item)
+    def include?(object)
+      each { |item| return true if object == item }
+      false
     end
     alias_method :member?, :include?
 
+    def any?
+      if block_given?
+        each { |item| return true if yield(item) }
+      else
+        each { |item| return true if item }
+      end
+      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
+      true
+    end
+
+    def none?
+      if block_given?
+        each { |item| return false if yield(item) }
+      else
+        each { |item| return false if item }
+      end
+      true
+    end
+
+    def find
+      return nil unless block_given?
+      each { |item| return item if yield(item) }
+    end
+    alias_method :detect, :find
+
     def eql?(other)
-      return true if other.equal?(self)
       return false unless other.is_a?(List)
-      other.head == head && other.tail.eql?(tail)
+
+      list = self
+      while !list.empty? && !other.empty?
+        return true if other.equal?(list)
+        return false unless other.is_a?(List)
+        return false unless other.head.eql?(list.head)
+        list = list.tail
+        other = other.tail
+      end
+      other.equal?(list)
     end
     alias_method :==, :eql?
 
@@ -128,8 +185,9 @@ module Hamster
     alias_method :clone, :dup
 
     def to_a
-      reduce([]) { |ary, item| ary << item }
+      reduce([]) { |a, item| a << item }
     end
+    alias_method :to_ary, :to_a
 
     def inspect
       to_a.inspect
@@ -208,56 +266,30 @@ module Hamster
         true
       end
 
-      def size
-        0
-      end
-      alias_method :length, :size
-
-      def each
-        block_given? or return self
-        nil
-      end
-
       def map
         self
       end
       alias_method :collect, :map
 
-      def reduce(memo)
-        memo
-      end
-      alias_method :inject, :reduce
-
       def filter
         self
       end
       alias_method :select, :filter
+      alias_method :find_all, :filter
 
       def reject
         self
       end
+      alias_method :delete_if, :reject
 
       def take_while
         self
       end
 
-      def drop_while
-        self
-      end
-
       def take(number)
         self
       end
 
-      def drop(number)
-        self
-      end
-
-      def include?(item)
-        false
-      end
-      alias_method :member?, :include?
-
     end
 
   end

data/lib/hamster/set.rb

@@ -45,13 +45,13 @@ module Hamster
     end
 
     def each
-      block_given? or return self
+      return self unless block_given?
       @trie.each { |entry| yield(entry.key) }
       self
     end
 
     def map
-      block_given? or return self
+      return self unless block_given?
       if empty?
         self
       else
@@ -61,13 +61,14 @@ module Hamster
     alias_method :collect, :map
 
     def reduce(memo)
-      block_given? or return memo
+      return memo unless block_given?
       @trie.reduce(memo) { |memo, entry| yield(memo, entry.key) }
     end
     alias_method :inject, :reduce
+    alias_method :fold, :reduce
 
     def filter
-      block_given? or return self
+      return self unless block_given?
       trie = @trie.filter { |entry| yield(entry.key) }
       if !trie.equal?(@trie)
         self.class.new(trie)
@@ -76,11 +77,13 @@ module Hamster
       end
     end
     alias_method :select, :filter
+    alias_method :find_all, :filter
 
     def reject
-      block_given? or return self
+      return self unless block_given?
       select { |item| !yield(item) }
     end
+    alias_method :delete_if, :reject
 
     def any?
       if block_given?
@@ -121,6 +124,10 @@ module Hamster
     end
     alias_method :clone, :dup
 
+    def to_a
+      reduce([]) { |a, item| a << item }
+    end
+
   end
 
 end

data/lib/hamster/version.rb

@@ -1,5 +1,5 @@
 module Hamster
 
-  VERSION = "0.1.13".freeze
+  VERSION = "0.1.14".freeze
 
 end

data/spec/hamster/hash/all_spec.rb

@@ -29,7 +29,7 @@ describe Hamster::Hash do
       describe "with a block" do
 
         it "returns true if the block always returns true" do
-          @hash.all? { |item| true }.should be_true
+          @hash.all? { |key, value| true }.should be_true
         end
 
         it "returns false if the block ever returns false" do

data/spec/hamster/hash/eql_spec.rb

@@ -6,20 +6,49 @@ describe Hamster::Hash do
 
     describe "##{method}" do
 
+      describe "returns false when comparing with" do
+
+        before do
+          @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
+        end
+
+        it "a standard hash" do
+          @hash.send(method, "A" => "aye", "B" => "bee", "C" => "see").should be_false
+        end
+
+        it "an aribtrary object" do
+          @hash.send(method, Object.new).should be_false
+        end
+
+      end
+
       [
-        [[], [], true],
-        [["A" => "aye"], [], false],
-        [[], ["A" => "aye"], false],
-        [["A" => "aye"], ["A" => "aye"], true],
-        [["A" => "aye"], ["B" => "bee"], false],
-        [["A" => "aye", "B" => "bee"], ["A" => "aye"], false],
-        [["A" => "aye"], ["A" => "aye", "B" => "bee"], false],
-        [["A" => "aye", "B" => "bee", "C" => "see"], ["A" => "aye", "B" => "bee", "C" => "see"], true],
-        [["C" => "see", "A" => "aye", "B" => "bee"], ["A" => "aye", "B" => "bee", "C" => "see"], true],
-      ].each do |a, b, result|
-
-        it "returns #{result} for #{a.inspect} and #{b.inspect}" do
-          Hamster.hash(*a).send(method, Hamster.hash(*b)).should == result
+        [{}, {}, true],
+        [{"A" => "aye"}, {}, false],
+        [{}, {"A" => "aye"}, false],
+        [{"A" => "aye"}, {"A" => "aye"}, true],
+        [{"A" => "aye"}, {"B" => "bee"}, false],
+        [{"A" => "aye", "B" => "bee"}, {"A" => "aye"}, false],
+        [{"A" => "aye"}, {"A" => "aye", "B" => "bee"}, false],
+        [{"A" => "aye", "B" => "bee", "C" => "see"}, {"A" => "aye", "B" => "bee", "C" => "see"}, true],
+        [{"C" => "see", "A" => "aye", "B" => "bee"}, {"A" => "aye", "B" => "bee", "C" => "see"}, true],
+      ].each do |a, b, expected|
+
+        describe "returns #{expected}" do
+
+          before do
+            @a = Hamster.hash(a)
+            @b = Hamster.hash(b)
+          end
+
+          it "for #{a.inspect} and #{b.inspect}" do
+            @a.send(method, @b).should == expected
+          end
+
+          it "for #{b.inspect} and #{a.inspect}" do
+            @b.send(method, @a).should == expected
+          end
+
         end
 
       end