hamster 0.1.8 → 0.1.11

data/README.rdoc

@@ -1,6 +1,6 @@
 = Hamster
 
-Hamster started out as an implementation of Hash Array Mapped Hashs (HAMT) for Ruby (see http://lamp.epfl.ch/papers/idealhashtrees.pdf) and has since expanded to include implementations of other Persistent Data Structures (see http://en.wikipedia.org/wiki/Persistent_data_structure) such as Sets, Lists, Stacks, etc.
+Hamster started out as an implementation of Hash Array Mapped Hashes (HAMT) for Ruby (see http://lamp.epfl.ch/papers/idealhashtrees.pdf) and has since expanded to include implementations of other Persistent Data Structures (see http://en.wikipedia.org/wiki/Persistent_data_structure) such as Sets, Lists, Stacks, etc.
 
 == Huh?
 
@@ -8,7 +8,7 @@ Persistent data structures have a really neat property: very efficient copy-on-w
 
   require 'hamster'
 
-  hash = Hamster::Hash.new
+  hash = Hamster.hash
 
   hash.put("Name", "Simon")
   hash.has_key?("Name")     # => false
@@ -20,8 +20,8 @@ Whoops! Remember, each call to <tt>#put</tt> creates an efficient copy containin
 
   require 'hamster'
 
-  original = Hamster::Hash.new
-  copy = hash.put("Name", "Simon")
+  original = Hamster.hash
+  copy = original.put("Name", "Simon")
 
   original.get("Name")             # => nil
   copy.get("Name")                 # => "Simon"
@@ -30,10 +30,10 @@ The same goes for <tt>#remove</tt>:
 
   require 'hamster'
 
-  original = Hamster::Hash.new
-  original = hash.put("Name", "Simon")
+  original = Hamster.hash
+  original = original.put("Name", "Simon")
   copy = hash.remove("Name")
-  
+
   original.get("Name")  # => Simon
   copy.get("Name")      # => nil
 
@@ -47,7 +47,7 @@ There's a potential performance hit when compared with MRI's built-in, native, h
 
   require 'hamster'
 
-  hash = Hamster::Hash.new
+  hash = Hamster.hash
   (1..10000).each { |i| hash = hash.put(i, i) }  # => 0.05s
   (1..10000).each { |i| hash.get(i) }  # => 0.008s
 
@@ -67,7 +67,7 @@ A more realistic comparison might look like:
 
   require 'hamster'
 
-  hash = Hamster::Hash.new
+  hash = Hamster.hash
   (1..10000).each { |i| hash = hash.put(i, i) }  # => 0.05s
   (1..10000).each { |i| hash.get(i) }  # => 0.008s
 
@@ -89,4 +89,28 @@ The <tt>Hamster::Hash</tt> version on the other hand was unchanged from the orig
 
 Well, I could show you one but I'd have to re-write--or at least wrap--most <tt>Hash</tt> methods to make it generic, or at least write some application-specific code that synchronised using a <tt>Mutex</tt> and ... well ... it's hard, I always make mistakes, I always end up with weird edge cases and race conditions so, I'll leave that as an exercise for you :)
 
-== And that, my friends, is why you might want to use one :)
+And that, my friends, is why you might want to use one :)
+
+== So, you mentioned Sets, Lists, and Stacks?
+
+Indeed I did.
+
+=== Lists
+
+list = Hamster.list(1, 2, 3)
+
+list.head    # => 1
+list.tail    # => Hamster.list(2, 3)
+
+def prime?(n)
+  2.upto(Math.sqrt(n).round) { |i| return false  if n % i == 0 }
+  true
+end
+
+Hamster.interval(10000, 1000000).filter { |i| prime?(i) }.take(3)
+
+=== Stacks
+
+=== Sets
+
+=== Hash

data/lib/hamster.rb

@@ -1,4 +1,3 @@
-require 'hamster/trie'
 require 'hamster/list'
 require 'hamster/stack'
 require 'hamster/set'

data/lib/hamster/hash.rb

@@ -1,72 +1,129 @@
+require 'hamster/trie'
+
 module Hamster
 
-  class Hash
+  def self.hash(pairs = {})
+    pairs.reduce(Hash.new) { |hash, pair| hash.put(pair.first, pair.last) }
+  end
 
-    def self.[](pairs)
-      pairs.reduce(self.new) { |hash, pair| hash.put(pair.first, pair.last) }
-    end
+  class Hash
 
     def initialize(trie = Trie.new)
       @trie = trie
     end
 
-    # Returns the number of key-value pairs in the hash.
     def size
       @trie.size
     end
+    alias_method :length, :size
 
-    # Returns <tt>true</tt> if the hash contains no key-value pairs.
     def empty?
       @trie.empty?
     end
 
-    # Returns <tt>true</tt> if the given key is present in the hash.
     def has_key?(key)
       @trie.has_key?(key)
     end
+    alias_method :key?, :has_key?
+    alias_method :include?, :has_key?
+    alias_method :member?, :has_key?
 
-    # Retrieves the value corresponding to the given key. If not found, returns <tt>nil</tt>.
     def get(key)
       entry = @trie.get(key)
       if entry
         entry.value
       end
     end
+    alias_method :[], :get
 
-    # Returns a copy of <tt>self</tt> with the given value associated with the key.
     def put(key, value)
       self.class.new(@trie.put(key, value))
     end
+    alias_method :[]=, :put
 
-    # Returns a copy of <tt>self</tt> with the given key/value pair removed. If not found, returns <tt>self</tt>.
     def remove(key)
-      copy = @trie.remove(key)
-      if !copy.equal?(@trie)
-        self.class.new(copy)
+      trie = @trie.remove(key)
+      if !trie.equal?(@trie)
+        self.class.new(trie)
       else
         self
       end
     end
 
-    # Calls <tt>block</tt> once for each entry in the hash, passing the key-value pair as parameters.
-    # Returns <tt>self</tt>
     def each
       block_given? or return enum_for(__method__)
-      @trie.each { |entry| yield entry.key, entry.value }
+      @trie.each { |entry| yield(entry.key, entry.value) }
       self
     end
 
-    # Returns <tt>true</tt> if . <tt>eql?</tt> is synonymous with <tt>==</tt>
+    def map
+      block_given? or return enum_for(:each)
+      if empty?
+        self
+      else
+        self.class.new(@trie.reduce(Trie.new) { |trie, entry| trie.put(*yield(entry.key, entry.value)) })
+      end
+    end
+    alias_method :collect, :map
+
+    def reduce(memo)
+      block_given? or return memo
+      @trie.reduce(memo) { |memo, entry| yield(memo, entry.key, entry.value) }
+    end
+    alias_method :inject, :reduce
+
+    def filter
+      block_given? or return enum_for(__method__)
+      trie = @trie.filter { |entry| yield(entry.key, entry.value) }
+      if !trie.equal?(@trie)
+        self.class.new(trie)
+      else
+        self
+      end
+    end
+    alias_method :select, :filter
+
+    def reject
+      block_given? or return enum_for(__method__)
+      select { |key, value| !yield(key, value) }
+    end
+
+    def any?
+      if block_given?
+        each { |key, value| return true if yield(key, value) }
+      else
+        each { |pair| return true if pair }
+      end
+      false
+    end
+
+    def all?
+      if block_given?
+        each { |key, value| return false unless yield(key, value) }
+      else
+        each { |pair| return false unless pair }
+      end
+      true
+    end
+
+    def none?
+      if block_given?
+        each { |key, value| return false if yield(key, value) }
+      else
+        each { |pair| return false if pair }
+      end
+      true
+    end
+
     def eql?(other)
       other.is_a?(self.class) && @trie.eql?(other.instance_eval{@trie})
     end
-    alias :== :eql?
+    alias_method :==, :eql?
 
-    # Returns <tt>self</tt>
     def dup
       self
     end
-    alias :clone :dup
+    alias_method :clone, :dup
 
   end
 

data/lib/hamster/list.rb

@@ -1,89 +1,125 @@
 module Hamster
 
-  class List
+  class << self
 
-    def self.[](*items)
-      list = self.new
-      items.reverse_each { |item| list = list.cons(item) }
-      list
+    def list(*items)
+      items.reverse.reduce(EmptyList) { |list, item| list.cons(item) }
     end
 
-    def initialize(head = nil, tail = self)
-      @head = head
-      @tail = tail
+    def interval(from, to)
+      if from > to
+        EmptyList
+      else
+        Stream.new(from) { interval(from.succ, to) }
+      end
     end
+    alias_method :range, :interval
+
+  end
+
+  module List
 
-    # Returns <tt>true</tt> if the list contains no items.
     def empty?
-      @tail.equal?(self)
+      false
     end
 
-    # Returns the number of items in the list.
     def size
-      if empty?
-        0
-      else
-        @tail.size + 1
-      end
+      tail.size + 1
     end
+    alias_method :length, :size
 
-    # Returns the first item.
-    def head
-      @head
+    def cons(item)
+      Sequence.new(item, self)
     end
 
-    # Returns a copy of <tt>self</tt> without the first item.
-    def tail
-      @tail
+    def each(&block)
+      block_given? or return self
+      yield(head)
+      tail.each(&block)
+      nil
     end
 
-    # Returns a copy of <tt>self</tt> with it as the head.
-    def cons(item)
-      self.class.new(item, self)
+    def map(&block)
+      block_given? or return self
+      Stream.new(yield(head)) { tail.map(&block) }
     end
 
-    # Calls <tt>block</tt> once for each item in the list, passing the item as the only parameter.
-    # Returns <tt>self</tt>
-    def each
-      block_given? or return enum_for(__method__)
-      unless empty?
-        yield(@head)
-        @tail.each { |item| yield(item) }
+    def reduce(memo, &block)
+      block_given? or return memo
+      tail.reduce(yield(memo, head), &block)
+    end
+    alias_method :inject, :reduce
+
+    def filter(&block)
+      block_given? or return self
+      if yield(head)
+        Stream.new(head) { tail.filter(&block) }
+      else
+        tail.filter(&block)
       end
-      self
     end
+    alias_method :select, :filter
 
-    # 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)
-      return true if other.empty? && empty?
-      return other.head == head && other.tail.eql?(tail)
+    def reject(&block)
+      block_given? or return self
+      if yield(head)
+        tail.reject(&block)
+      else
+        Stream.new(head) { tail.reject(&block) }
+      end
     end
-    alias :== :eql?
 
-    # Returns <tt>self</tt>
-    def dup
-      self
+    def take_while(&block)
+      block_given? or return self
+      if yield(head)
+        Stream.new(head) { tail.take_while(&block) }
+      else
+        EmptyList
+      end
     end
-    alias :clone :dup
 
-    def map
-      if empty?
+    def drop_while(&block)
+      block_given? or return self
+      if yield(head)
+        tail.drop_while(&block)
+      else
         self
+      end
+    end
+
+    def take(number)
+      if number > 0
+        Stream.new(head) { tail.take(number - 1) }
       else
-        @tail.map { |item| yield(item) }.cons(yield(@head))
+        EmptyList
       end
     end
 
-    def reduce(memo)
-      if empty?
-        memo
+    def drop(number)
+      if number > 0
+        tail.drop(number - 1)
       else
-        @tail.reduce(yield(memo, @head)) { |memo, item| yield(memo, item) }
+        self
       end
     end
 
+    def include?(item)
+      item == head || tail.include?(item)
+    end
+    alias_method :member?, :include?
+
+    def eql?(other)
+      return true if other.equal?(self)
+      return false unless other.is_a?(List)
+      other.head == head && other.tail.eql?(tail)
+    end
+    alias_method :==, :eql?
+
+    def dup
+      self
+    end
+    alias_method :clone, :dup
+
     private
 
     def method_missing(name, *args, &block)
@@ -99,7 +135,7 @@ module Hamster
     # identify the series of car and cdr operations that is performed by the function. The order in which the 'a's and
     # 'd's appear is the inverse of the order in which the corresponding operations are performed.
     def accessor(sequence)
-      sequence.split(//).reverse!.inject(self) do |memo, char|
+      sequence.split(//).reverse!.reduce(self) do |memo, char|
         case char
         when "a" then memo.head
         when "d" then memo.tail
@@ -109,4 +145,105 @@ module Hamster
 
   end
 
+  class Sequence
+
+    include List
+
+    attr_reader :head, :tail
+
+    def initialize(head, tail)
+      @head = head
+      @tail = tail
+    end
+
+  end
+
+  class Stream
+
+    include List
+
+    attr_reader :head
+
+    def initialize(head, &tail)
+      @head = head
+      @tail = tail
+    end
+
+    def tail
+      @tail.call
+    end
+
+  end
+
+  module EmptyList
+
+    class << self
+
+      include List
+
+      def head
+        nil
+      end
+
+      def tail
+        self
+      end
+
+      def empty?
+        true
+      end
+
+      def size
+        0
+      end
+      alias_method :length, :size
+
+      def each
+        block_given? or return self
+        nil
+      end
+
+      def map
+        self
+      end
+
+      def reduce(memo)
+        memo
+      end
+      alias_method :inject, :reduce
+
+      def filter
+        self
+      end
+      alias_method :select, :filter
+
+      def reject
+        self
+      end
+
+      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
+
 end