hamster 0.1.23 → 0.2.0

data/History.rdoc

@@ -1,3 +1,29 @@
+=== 0.2.0 / 2010-01-14
+
+* List methods that return lists are now all lazy. Not sure what, if any, negative impact this will have but the positives have so far been well worth it.
+
+* Ensure List#eql? (and #==) doesn't accidentally consider an empty list to be equal to an empty array!
+
+* Ensure List responds_to? cadr and friends.
+
+* Stream now releases the block for garbage collection once called.
+
+* Implement List#combinations.
+
+* Implement List#inits.
+
+* Implement List#tails.
+
+* Implement Hash#uniq.
+
+* Alias #uniq as #remove_duplicates.
+
+* Alias #all? as #forall?
+
+* Implement Set#product.
+
+* Implement Set#sum.
+
 === 0.1.23 / 2010-01-11
 
 * Implement List#product.

data/README.rdoc

@@ -170,7 +170,7 @@ How is this even possible? It's possible because <tt>IO#to_list</tt> creates a l
 
 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 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, and a little more memory hungry, than I would otherwise have preferred.
+Performance is pretty good--especially with lazy lists--but there are some things which may blow the stack due to a lack of Tail-Call-Optimisation in Ruby.
 
 Documentation is sparse but I've tried as best I can to write specs that read 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.rb

@@ -1,6 +1,6 @@
+require 'hamster/core_ext'
 require 'hamster/list'
 require 'hamster/stack'
 require 'hamster/set'
 require 'hamster/hash'
-require 'hamster/core_ext'
 require 'hamster/version'

data/lib/hamster/core_ext/io.rb

@@ -7,11 +7,13 @@ module Hamster
     module IO
 
       def to_list(sep = $/)
-        line = gets(sep)
-        if line
-          Stream.new(line) { to_list }
-        else
-          EmptyList
+        Stream.new do
+          line = gets(sep)
+          if line
+            Sequence.new(line, to_list)
+          else
+            EmptyList
+          end
         end
       end
 

data/lib/hamster/hash.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require 'hamster/trie'
 
 module Hamster
@@ -8,6 +10,8 @@ module Hamster
 
   class Hash
 
+    extend Forwardable
+
     def initialize(trie = Trie.new)
       @trie = trie
     end
@@ -15,19 +19,19 @@ module Hamster
     def size
       @trie.size
     end
-    alias_method :length, :size
+    def_delegator :self, :size, :length
 
     def empty?
       @trie.empty?
     end
-    alias_method :null?, :empty?
+    def_delegator :self, :empty?, :null?
 
     def has_key?(key)
       @trie.has_key?(key)
     end
-    alias_method :key?, :has_key?
-    alias_method :include?, :has_key?
-    alias_method :member?, :has_key?
+    def_delegator :self, :has_key?, :key?
+    def_delegator :self, :has_key?, :include?
+    def_delegator :self, :has_key?, :member?
 
     def get(key)
       entry = @trie.get(key)
@@ -35,12 +39,12 @@ module Hamster
         entry.value
       end
     end
-    alias_method :[], :get
+    def_delegator :self, :get, :[]
 
     def put(key, value)
       self.class.new(@trie.put(key, value))
     end
-    alias_method :[]=, :put
+    def_delegator :self, :put, :[]=
 
     def delete(key)
       trie = @trie.delete(key)
@@ -55,7 +59,7 @@ module Hamster
       return self unless block_given?
       @trie.each { |entry| yield(entry.key, entry.value) }
     end
-    alias_method :foreach, :each
+    def_delegator :self, :each, :foreach
 
     def map
       return self unless block_given?
@@ -65,14 +69,14 @@ module Hamster
         self.class.new(@trie.reduce(Trie.new) { |trie, entry| trie.put(*yield(entry.key, entry.value)) })
       end
     end
-    alias_method :collect, :map
+    def_delegator :self, :map, :collect
 
     def reduce(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_delegator :self, :reduce, :inject
+    def_delegator :self, :reduce, :fold
 
     def filter
       return self unless block_given?
@@ -83,26 +87,23 @@ module Hamster
         self.class.new(trie)
       end
     end
-    alias_method :select, :filter
-    alias_method :find_all, :filter
+    def_delegator :self, :filter, :select
+    def_delegator :self, :filter, :find_all
 
     def remove
       return self unless block_given?
       filter { |key, value| !yield(key, value) }
     end
-    alias_method :reject, :remove
-    alias_method :delete_if, :remove
+    def_delegator :self, :remove, :reject
+    def_delegator :self, :remove, :delete_if
 
     def any?
-      if block_given?
-        each { |key, value| return true if yield(key, value) }
-      else
-        return !empty?
-      end
+      return !empty? unless block_given?
+      each { |key, value| return true if yield(key, value) }
       false
     end
-    alias_method :exist?, :any?
-    alias_method :exists?, :any?
+    def_delegator :self, :any?, :exist?
+    def_delegator :self, :any?, :exists?
 
     def all?
       if block_given?
@@ -110,25 +111,26 @@ module Hamster
       end
       true
     end
+    def_delegator :self, :all?, :forall?
 
     def none?
-      if block_given?
-        each { |key, value| return false if yield(key, value) }
-      else
-        return empty?
-      end
+      return empty? unless block_given?
+      each { |key, value| return false if yield(key, value) }
       true
     end
 
     def eql?(other)
       other.is_a?(self.class) && @trie.eql?(other.instance_eval{@trie})
     end
-    alias_method :==, :eql?
+    def_delegator :self, :eql?, :==
 
     def dup
       self
     end
-    alias_method :clone, :dup
+    def_delegator :self, :dup, :clone
+    def_delegator :self, :dup, :uniq
+    def_delegator :self, :dup, :nub
+    def_delegator :self, :dup, :remove_duplicates
 
   end
 

data/lib/hamster/list.rb

@@ -1,3 +1,4 @@
+require 'forwardable'
 require 'monitor'
 
 require 'hamster/set'
@@ -6,23 +7,25 @@ module Hamster
 
   class << self
 
+    extend Forwardable
+
     def list(*items)
       items.reverse.reduce(EmptyList) { |list, item| list.cons(item) }
     end
 
     def stream(&block)
       return EmptyList unless block_given?
-      Stream.new(yield) { stream(&block) }
+      Stream.new { Sequence.new(yield, stream(&block)) }
     end
 
     def interval(from, to)
       return EmptyList if from > to
-      Stream.new(from) { interval(from.succ, to) }
+      Stream.new { Sequence.new(from, interval(from.succ, to)) }
     end
-    alias_method :range, :interval
+    def_delegator :self, :interval, :range
 
     def repeat(item)
-      Stream.new(item) { repeat(item) }
+      Stream.new { Sequence.new(item, repeat(item)) }
     end
 
     def replicate(number, item)
@@ -30,29 +33,37 @@ module Hamster
     end
 
     def iterate(item, &block)
-      Stream.new(item) { iterate(yield(item), &block) }
+      Stream.new { Sequence.new(item, iterate(yield(item), &block)) }
     end
 
   end
 
   module List
 
+    extend Forwardable
+
     Undefined = Object.new
 
+    CADR = /^c([ad]+)r$/
+
+    def first
+      head
+    end
+
     def empty?
       false
     end
-    alias_method :null?, :empty?
+    def_delegator :self, :empty?, :null?
 
     def size
       reduce(0) { |memo, item| memo.succ }
     end
-    alias_method :length, :size
+    def_delegator :self, :size, :length
 
     def cons(item)
       Sequence.new(item, self)
     end
-    alias_method :>>, :cons
+    def_delegator :self, :cons, :>>
 
     def each
       return self unless block_given?
@@ -62,13 +73,19 @@ module Hamster
         list = list.tail
       end
     end
-    alias_method :foreach, :each
+    def_delegator :self, :each, :foreach
 
     def map(&block)
       return self unless block_given?
-      Stream.new(yield(head)) { tail.map(&block) }
+      Stream.new do
+        if empty?
+          self
+        else
+          Sequence.new(yield(head), tail.map(&block))
+        end
+      end
     end
-    alias_method :collect, :map
+    def_delegator :self, :map, :collect
 
     def reduce(memo = Undefined, &block)
       return tail.reduce(head, &block) if memo.equal?(Undefined)
@@ -76,80 +93,102 @@ module Hamster
       each { |item| memo = yield(memo, item)  }
       memo
     end
-    alias_method :inject, :reduce
-    alias_method :fold, :reduce
+    def_delegator :self, :reduce, :inject
+    def_delegator :self, :reduce, :fold
 
     def filter(&block)
       return self unless block_given?
-      list = self
-      while !yield(list.head)
-        list = list.tail
-        return list if list.empty?
+      Stream.new do
+        if empty?
+          self
+        elsif yield(head)
+          Sequence.new(head, tail.filter(&block))
+        else
+          tail.filter(&block)
+        end
       end
-      Stream.new(list.head) { list.tail.filter(&block) }
     end
-    alias_method :select, :filter
-    alias_method :find_all, :filter
+    def_delegator :self, :filter, :select
+    def_delegator :self, :filter, :find_all
 
     def remove(&block)
       return self unless block_given?
       filter { |item| !yield(item) }
     end
-    alias_method :reject, :remove
-    alias_method :delete_if, :remove
+    def_delegator :self, :remove, :reject
+    def_delegator :self, :remove, :delete_if
 
     def take_while(&block)
       return self unless block_given?
-      if yield(head)
-        Stream.new(head) { tail.take_while(&block) }
-      else
-        EmptyList
+      Stream.new do
+        if empty?
+          self
+        elsif yield(head)
+          Sequence.new(head, tail.take_while(&block))
+        else
+          EmptyList
+        end
       end
     end
 
-    def drop_while
+    def drop_while(&block)
       return self unless block_given?
-      list = self
-      while !list.empty? && yield(list.head)
-        list = list.tail
+      Stream.new do
+        if empty?
+          self
+        elsif yield(head)
+          tail.drop_while(&block)
+        else
+          self
+        end
       end
-      list
     end
 
     def take(number)
-      return EmptyList unless number > 0
-      Stream.new(head) { tail.take(number - 1) }
+      Stream.new do
+        if empty?
+          self
+        elsif number > 0
+          Sequence.new(head, tail.take(number - 1))
+        else
+          EmptyList
+        end
+      end
     end
 
     def drop(number)
-      list = self
-      while !list.empty? && number > 0
-        number -= 1
-        list = list.tail
+      Stream.new do
+        if empty?
+          self
+        elsif number > 0
+          tail.drop(number - 1)
+        else
+          self
+        end
       end
-      list
     end
 
     def include?(object)
       any? { |item| item == object }
     end
-    alias_method :member?, :include?
-    alias_method :contains?, :include?
-    alias_method :elem?, :include?
+    def_delegator :self, :include?, :member?
+    def_delegator :self, :include?, :contains?
+    def_delegator :self, :include?, :elem?
 
     def any?
       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_delegator :self, :any?, :exist?
+    def_delegator :self, :any?, :exists?
 
     def all?
       return all? { |item| item } unless block_given?
       each { |item| return false unless yield(item) }
       true
     end
+    def_delegator :self, :all?, :forall?
 
     def none?
       return none? { |item| item } unless block_given?
@@ -171,19 +210,25 @@ module Hamster
       return nil unless block_given?
       each { |item| return item if yield(item) }
     end
-    alias_method :detect, :find
+    def_delegator :self, :find, :detect
 
     def partition(&block)
       return self unless block_given?
-      Stream.new(filter(&block)) { Sequence.new(remove(&block)) }
+      Stream.new { Sequence.new(filter(&block), Sequence.new(remove(&block))) }
     end
 
     def append(other)
-      Stream.new(head) { tail.append(other) }
+      Stream.new do
+        if empty?
+          other
+        else
+          Sequence.new(head, tail.append(other))
+        end
+      end
     end
-    alias_method :concat, :append
-    alias_method :cat, :append
-    alias_method :+, :append
+    def_delegator :self, :append, :concat
+    def_delegator :self, :append, :cat
+    def_delegator :self, :append, :+
 
     def reverse
       reduce(EmptyList) { |list, item| list.cons(item) }
@@ -193,37 +238,49 @@ module Hamster
       return minimum { |minimum, item| item <=> minimum } unless block_given?
       reduce { |minimum, item| yield(minimum, item) < 0 ? item : minimum }
     end
-    alias_method :min, :minimum
+    def_delegator :self, :minimum, :min
 
     def maximum(&block)
       return maximum { |maximum, item| item <=> maximum } unless block_given?
       reduce { |maximum, item| yield(maximum, item) > 0 ? item : maximum }
     end
-    alias_method :max, :maximum
+    def_delegator :self, :maximum, :max
 
     def grep(pattern, &block)
       filter { |item| pattern === item }.map(&block)
     end
 
     def zip(other)
-      Stream.new(Sequence.new(other.head).cons(head)) { tail.zip(other.tail) }
+      Stream.new do
+        if empty? && other.empty?
+          self
+        else
+          Sequence.new(Sequence.new(head, Sequence.new(other.head)), tail.zip(other.tail))
+        end
+      end
     end
 
     def cycle
-      Stream.new(head) { tail.append(self.cycle) }
+      Stream.new do
+        if empty?
+          self
+        else
+          Sequence.new(head, tail.append(self.cycle))
+        end
+      end
     end
 
     def split_at(number)
-      Sequence.new(drop(number)).cons(take(number))
+      Sequence.new(take(number), Sequence.new(drop(number)))
     end
 
     def span(&block)
-      return Sequence.new(EmptyList).cons(self) unless block_given?
-      Stream.new(take_while(&block)) { Sequence.new(drop_while(&block)) }
+      return Sequence.new(self, Sequence.new(EmptyList)) unless block_given?
+      Sequence.new(take_while(&block), Sequence.new(drop_while(&block)))
     end
 
     def break(&block)
-      return Sequence.new(EmptyList).cons(self) unless block_given?
+      return Sequence.new(self, Sequence.new(EmptyList)) unless block_given?
       span { |item| !yield(item) }
     end
 
@@ -236,42 +293,56 @@ module Hamster
     end
 
     def sort(&block)
-      Hamster.list(*to_a.sort(&block))
+      Stream.new do
+        Hamster.list(*to_a.sort(&block))
+      end
     end
 
     def sort_by(&block)
       return sort unless block_given?
-      Hamster.list(*to_a.sort_by(&block))
+      Stream.new do
+        Hamster.list(*to_a.sort_by(&block))
+      end
     end
 
     def join(sep = "")
+      return "" if empty?
       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) } }
+      Stream.new do
+        if tail.empty?
+          self
+        else
+          Sequence.new(head, Sequence.new(sep, tail.intersperse(sep)))
+        end
+      end
     end
 
     def uniq(items = Set.new)
-      list = self
-      while !list.empty? && items.include?(list.head)
-        list = list.tail
+      Stream.new do
+        if empty?
+          self
+        elsif items.include?(head)
+          tail.uniq(items)
+        else
+          Sequence.new(head, tail.uniq(items.add(head)))
+        end
       end
-      return list if list.empty?
-      Stream.new(list.head) { list.tail.uniq(items.add(list.head)) }
     end
-    alias_method :nub, :uniq
+    def_delegator :self, :uniq, :nub
+    def_delegator :self, :uniq, :remove_duplicates
 
     def union(other)
       self.append(other).uniq
     end
-    alias_method :|, :union
+    def_delegator :self, :union, :|
 
     def init
       return EmptyList if tail.empty?
-      Stream.new(head) { tail.init }
+      Stream.new { Sequence.new(head, tail.init) }
     end
 
     def last
@@ -290,6 +361,38 @@ module Hamster
       reduce(0, &:+)
     end
 
+    def tails
+      Stream.new do
+        if empty?
+          Sequence.new(self)
+        else
+          Sequence.new(self, tail.tails)
+        end
+      end
+    end
+
+    def inits
+      Stream.new do
+        if empty?
+          Sequence.new(self)
+        else
+          Sequence.new(EmptyList, tail.inits.map { |list| list.cons(head) })
+        end
+      end
+    end
+
+    def combinations(number)
+      return Sequence.new(EmptyList) if number == 0
+      Stream.new do
+        if empty?
+          self
+        else
+          tail.combinations(number - 1).map { |list| list.cons(head) }.append(tail.combinations(number))
+        end
+      end
+    end
+    def_delegator :self, :combinations, :combination
+
     def eql?(other)
       return false unless other.is_a?(List)
 
@@ -301,20 +404,21 @@ module Hamster
         list = list.tail
         other = other.tail
       end
-      other.equal?(list)
+
+      other.empty? && list.empty?
     end
-    alias_method :==, :eql?
+    def_delegator :self, :eql?, :==
 
     def dup
       self
     end
-    alias_method :clone, :dup
+    def_delegator :self, :dup, :clone
 
     def to_a
       reduce([]) { |a, item| a << item }
     end
-    alias_method :to_ary, :to_a
-    alias_method :entries, :to_a
+    def_delegator :self, :to_a, :to_ary
+    def_delegator :self, :to_a, :entries
 
     def to_list
       self
@@ -324,10 +428,14 @@ module Hamster
       to_a.inspect
     end
 
+    def respond_to?(name, include_private = false)
+      super || CADR === name
+    end
+
     private
 
     def method_missing(name, *args, &block)
-      if name.to_s =~ /^c([ad]+)r$/
+      if CADR === name
         accessor($1)
       else
         super
@@ -354,7 +462,6 @@ module Hamster
     include List
 
     attr_reader :head, :tail
-    alias_method :first, :head
 
     def initialize(head, tail = EmptyList)
       @head = head
@@ -367,22 +474,33 @@ module Hamster
 
     include List
 
-    attr_reader :head
-    alias_method :first, :head
-
-    def initialize(head, &tail)
-      @head = head
-      @tail = tail
+    def initialize(&block)
+      @block = block
       @mutex = Mutex.new
     end
 
+    def head
+      target.head
+    end
+
     def tail
+      target.tail
+    end
+
+    def empty?
+      target.empty?
+    end
+
+    private
+
+    def target
       @mutex.synchronize do
-        unless defined?(@value)
-          @value = @tail.call
+        unless defined?(@target)
+          @target = @block.call
+          @block = nil
         end
       end
-      @value
+      @target
     end
 
   end
@@ -396,7 +514,6 @@ module Hamster
       def head
         nil
       end
-      alias_method :first, :head
 
       def tail
         self
@@ -405,48 +522,6 @@ module Hamster
       def empty?
         true
       end
-      alias_method :null?, :empty?
-
-      def map
-        self
-      end
-      alias_method :collect, :map
-
-      def filter
-        self
-      end
-      alias_method :select, :filter
-      alias_method :find_all, :filter
-
-      def remove
-        self
-      end
-      alias_method :reject, :remove
-      alias_method :delete_if, :remove
-
-      def take_while
-        self
-      end
-
-      def take(number)
-        self
-      end
-
-      def append(other)
-        other
-      end
-      alias_method :concat, :append
-      alias_method :cat, :append
-      alias_method :+, :append
-
-      def zip(other)
-        return super unless other.empty?
-        self
-      end
-
-      def cycle
-        self
-      end
 
     end