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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a6d9d9d40fec03b2572ac9d6357672168a92beb
-  data.tar.gz: 3cb07caf01439c766a95e1e95191df5385e71fc1
+  metadata.gz: a12201961b658581cc147e8a0c99fdc7003bf3b0
+  data.tar.gz: 3f24be00255e640a0afcefd374f6e3d16e619e5c
 SHA512:
-  metadata.gz: 3b7b5121f99a8d3cb4d1c749b29c8207b902ca37f1065538b5890f4acf5c647d40bb21900ab50a48979c9abab6efe2dddc2269874dc9e7db44d5aaa6ab9d22fb
-  data.tar.gz: 4fb92d1cbe3e221476930d7e20585acf9ebd53cb6892c4157667a6e1d3402c90804bfebe28f41d69577026d7904f266eb34dae94d41e42f2cf962757c5cecebb
+  metadata.gz: abd019d8bcc64d60d75d734a8ee0e08e549ab3662b2e1638f25afb331a3fa7981b0f45f571625bc61f2a36b17bbce44c0a862aa4586f95f9949949ddc26dc1c0
+  data.tar.gz: 283b36da83e8dda6ab822e430eb2503d7abdf7be6cb142e0c217052acbd2cafcac52c0833e2a156018436cf6cb86b947c7c10a76a5dcfa4b9ab8247a88d6d35d

data/lib/hamster/groupable.rb

@@ -0,0 +1,12 @@
+module Hamster
+  module Groupable
+    def group_by_with(empty_group, &block)
+      return group_by { |item| item } unless block_given?
+      reduce(EmptyHash) do |hash, item|
+        key = yield(item)
+        group = hash.get(key) || empty_group
+        hash.put(key, group.conj(item))
+      end
+    end
+  end
+end

data/lib/hamster/hash.rb

@@ -6,7 +6,7 @@ require "hamster/trie"
 require "hamster/list"
 
 module Hamster
-  def self.hash(pairs = {}, &block)
+  def self.hash(pairs = nil, &block)
     Hash.new(pairs, &block)
   end
 
@@ -15,16 +15,25 @@ module Hamster
     include Immutable
 
     class << self
-      def new(pairs = {}, &block)
-        @empty ||= super()
-        pairs.reduce(block_given? ? super(&block) : @empty) { |hash, pair| hash.put(pair.first, pair.last) }
+      alias :alloc :new
+
+      def new(pairs = nil, &block)
+        if pairs.nil? && block.nil?
+          empty
+        elsif pairs.empty?
+          alloc(EmptyTrie, block)
+        else
+          alloc(Trie[pairs], block)
+        end
       end
 
-      attr_reader :empty
+      def empty
+        @empty ||= self.alloc
+      end
     end
 
-    def initialize(&block)
-      @trie = EmptyTrie
+    def initialize(trie = EmptyTrie, block = nil)
+      @trie    = trie
       @default = block
     end
 
@@ -143,7 +152,9 @@ module Hamster
     def_delegator :self, :find, :detect
 
     def merge(other)
-      transform { @trie = other.reduce(@trie, &:put) }
+      transform do
+        other.each { |key, value| @trie = @trie.put(key, value) }
+      end
     end
     def_delegator :self, :merge, :+
 
@@ -156,7 +167,7 @@ module Hamster
     end
 
     def keys
-      reduce(Hamster.set) { |keys, key, value| keys.add(key) }
+      Hamster::Set.alloc(@trie)
     end
 
     def values
@@ -167,10 +178,15 @@ module Hamster
       self.class.empty
     end
 
+    # Value-and-type equality
     def eql?(other)
       instance_of?(other.class) && @trie.eql?(other.instance_variable_get(:@trie))
     end
-    def_delegator :self, :eql?, :==
+
+    # Value equality, will do type coercion
+    def ==(other)
+      self.eql?(other) || (other.respond_to?(:to_hash) && to_hash.eql?(other.to_hash))
+    end
 
     def hash
       keys.sort.reduce(0) do |hash, key|
@@ -186,7 +202,7 @@ module Hamster
       "{#{reduce([]) { |memo, key, value| memo << "#{key.inspect} => #{value.inspect}" }.join(", ")}}"
     end
 
-    def marshal_dump
+    def to_hash
       output = {}
       each do |key, value|
         output[key] = value
@@ -194,6 +210,10 @@ module Hamster
       output
     end
 
+    def marshal_dump
+      to_hash
+    end
+
     def marshal_load(dictionary)
       @trie = dictionary.reduce EmptyTrie do |trie, key_value|
         trie.put(key_value.first, key_value.last)
@@ -201,5 +221,5 @@ module Hamster
     end
   end
 
-  EmptyHash = Hamster::Hash.new
+  EmptyHash = Hamster::Hash.empty
 end

data/lib/hamster/list.rb

@@ -4,6 +4,7 @@ require "thread"
 require "hamster/core_ext/enumerable"
 require "hamster/undefined"
 require "hamster/enumerable"
+require "hamster/groupable"
 require "hamster/tuple"
 require "hamster/sorter"
 require "hamster/hash"
@@ -144,6 +145,7 @@ module Hamster
   module List
     extend Forwardable
     include Enumerable
+    include Groupable
 
     CADR = /^c([ad]+)r$/
 
@@ -151,7 +153,16 @@ module Hamster
     def_delegator :self, :empty?, :null?
 
     def size
-      reduce(0) { |memo, item| memo.next }
+      result, list = 0, self
+      until list.empty?
+        if list.cached_size?
+          return result + list.size
+        else
+          result += 1
+        end
+        list = list.tail
+      end
+      result
     end
     def_delegator :self, :size, :length
 
@@ -159,6 +170,8 @@ module Hamster
       Sequence.new(item, self)
     end
     def_delegator :self, :cons, :>>
+    def_delegator :self, :cons, :conj
+    def_delegator :self, :cons, :conjoin
 
     def add(item)
       append(Hamster.list(item))
@@ -387,11 +400,7 @@ module Hamster
     end
 
     def group_by(&block)
-      return group_by { |item| item } unless block_given?
-      reduce(EmptyHash) do |hash, item|
-        key = yield(item)
-        hash.put(key, (hash.get(key) || EmptyList).cons(item))
-      end
+      group_by_with(EmptyList, &block)
     end
     def_delegator :self, :group_by, :group
 
@@ -466,6 +475,7 @@ module Hamster
       end
     end
 
+    # Value-and-type equality
     def eql?(other)
       list = self
       loop do
@@ -478,7 +488,12 @@ module Hamster
         other = other.tail
       end
     end
-    def_delegator :self, :eql?, :==
+
+    # Value equality, will do type coercion on arrays and array-like objects
+    def ==(other)
+      self.eql?(other) ||
+        other.respond_to?(:to_ary) && to_ary.eql?(other.to_ary)
+    end
 
     def hash
       reduce(0) { |hash, item| (hash << 5) - hash + item.hash }
@@ -505,23 +520,28 @@ module Hamster
       super || !!name.to_s.match(CADR)
     end
 
+    def cached_size?
+      false
+    end
+
     private
 
     def method_missing(name, *args, &block)
-      return accessor(Regexp.last_match[1]) if name.to_s.match(CADR)
-      super
-    end
-
-    # Perform compositions of <tt>car</tt> and <tt>cdr</tt> operations. Their names consist of a 'c', followed by at
-    # least one 'a' or 'd', and finally an 'r'. The series of 'a's and 'd's in each function's name is chosen to
-    # 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.reverse.each_char.reduce(self) do |memo, char|
-        case char
-        when "a" then memo.head
-        when "d" then memo.tail
-        end
+      if name.to_s.match(CADR)
+        # Perform compositions of car and cdr operations. Their names consist of a 'c',
+        # followed by at least one 'a' or 'd', and finally an 'r'. The series of 'a's and
+        # 'd's in the method name identify the series of car and cdr operations performed.
+        # The order in which the 'a's and 'd's appear is the inverse of the order in which
+        # the corresponding operations are performed.
+        code = "def #{name}; self."
+        code << Regexp.last_match[1].reverse.chars.map do |char|
+          {'a' => 'head', 'd' => 'tail'}[char]
+        end.join('.')
+        code << '; end'
+        List.class_eval(code)
+        send(name, *args, &block)
+      else
+        super
       end
     end
   end
@@ -544,11 +564,20 @@ module Hamster
     def initialize(head, tail = EmptyList)
       @head = head
       @tail = tail
+      @size = tail.cached_size? ? tail.size + 1 : nil
     end
 
     def empty?
       false
     end
+
+    def size
+      @size || super
+    end
+
+    def cached_size?
+      @size != nil
+    end
   end
 
   # Lazy list stream
@@ -569,13 +598,22 @@ module Hamster
 
     def initialize(&block)
       @block = block
-      @lock = Mutex.new
+      @lock  = Mutex.new
+      @size  = nil
     end
 
     def_delegator :target, :head
     def_delegator :target, :tail
     def_delegator :target, :empty?
 
+    def size
+      @size ||= super
+    end
+
+    def cached_size?
+      @size != nil
+    end
+
     protected
 
     def vivify
@@ -616,6 +654,14 @@ module Hamster
       def empty?
         true
       end
+
+      def size
+        0
+      end
+
+      def cached_size?
+        true
+      end
     end
   end
 end

data/lib/hamster/queue.rb

@@ -38,6 +38,8 @@ module Hamster
     end
     def_delegator :self, :enqueue, :<<
     def_delegator :self, :enqueue, :add
+    def_delegator :self, :enqueue, :conj
+    def_delegator :self, :enqueue, :conjoin
 
     def dequeue
       front = @front
@@ -66,20 +68,17 @@ module Hamster
     def_delegator :self, :eql?, :==
 
     def to_a
-      to_list.to_a
+      @front.to_a.concat(@rear.to_a.tap { |a| a.reverse! })
     end
     def_delegator :self, :to_a, :entries
-
-    def to_ary
-      to_list.to_ary
-    end
+    def_delegator :self, :to_a, :to_ary
 
     def to_list
       @front.append(@rear.reverse)
     end
 
     def inspect
-      to_list.inspect
+      to_a.inspect
     end
   end
 

data/lib/hamster/set.rb

@@ -2,19 +2,33 @@ require "forwardable"
 require "hamster/immutable"
 require "hamster/undefined"
 require "hamster/enumerable"
+require "hamster/groupable"
 require "hamster/sorter"
 require "hamster/trie"
 require "hamster/list"
 
 module Hamster
   def self.set(*items)
-    items.reduce(EmptySet) { |set, item| set.add(item) }
+    Set.new(*items)
   end
 
   class Set
     extend Forwardable
     include Immutable
     include Enumerable
+    include Groupable
+
+    class << self
+      alias :alloc :new
+
+      def new(*items)
+        items.empty? ? empty : alloc(Trie[items.map! { |x| [x, nil] }])
+      end
+
+      def empty
+        @empty ||= self.alloc
+      end
+    end
 
     def initialize(trie = EmptyTrie)
       @trie = trie
@@ -34,6 +48,8 @@ module Hamster
       transform_unless(include?(item)) { @trie = @trie.put(item, nil) }
     end
     def_delegator :self, :add, :<<
+    def_delegator :self, :add, :conj
+    def_delegator :self, :add, :conjoin
 
     def delete(item)
       trie = @trie.delete(item)
@@ -55,12 +71,12 @@ module Hamster
     def filter
       return self unless block_given?
       trie = @trie.filter { |entry| yield(entry.key) }
-      return EmptySet if trie.empty?
+      return self.class.empty if trie.empty?
       transform_unless(trie.equal?(@trie)) { @trie = trie }
     end
 
     def include?(object)
-      any? { |item| item.eql?(object) }
+      @trie.key?(object)
     end
 
     def head
@@ -100,8 +116,12 @@ module Hamster
     def_delegator :self, :intersection, :&
 
     def difference(other)
-      trie = @trie.filter { |entry| !other.include?(entry.key) }
-      transform_unless(trie.equal?(@trie)) { @trie = trie }
+      trie = if (@trie.size <= other.size) && (other.is_a?(Hamster::Set) || (defined?(::Set) && other.is_a?(::Set)))
+        @trie.filter { |entry| !other.include?(entry.key) }
+      else
+        other.reduce(@trie) { |trie, item| trie.delete(item) }
+      end
+      trie.empty? ? self.class.empty : self.class.alloc(trie)
     end
     def_delegator :self, :difference, :diff
     def_delegator :self, :difference, :subtract
@@ -121,27 +141,29 @@ module Hamster
     end
 
     def flatten
-      reduce(EmptySet) do |set, item|
+      reduce(self.class.empty) do |set, item|
         next set.union(item.flatten) if item.is_a?(Set)
         set.add(item)
       end
     end
 
     def group_by(&block)
-      return group_by { |item| item } unless block_given?
-      reduce(EmptyHash) do |hash, item|
-        key = yield(item)
-        hash.put(key, (hash.get(key) || EmptySet).add(item))
-      end
+      group_by_with(self.class.empty, &block)
     end
     def_delegator :self, :group_by, :group
 
     def clear
-      EmptySet
+      self.class.empty
     end
 
     def eql?(other)
-      instance_of?(other.class) && @trie.eql?(other.instance_variable_get(:@trie))
+      return false if not instance_of?(other.class)
+      other_trie = other.instance_variable_get(:@trie)
+      return false if @trie.size != other_trie.size
+      @trie.each do |entry|
+        return false if !other_trie.key?(entry.key)
+      end
+      true
     end
     def_delegator :self, :eql?, :==
 
@@ -161,7 +183,21 @@ module Hamster
     def inspect
       "{#{to_a.inspect[1..-2]}}"
     end
+
+    def marshal_dump
+      output = {}
+      each do |key|
+        output[key] = nil
+      end
+      output
+    end
+
+    def marshal_load(dictionary)
+      @trie = dictionary.reduce(EmptyTrie) do |trie, key_value|
+        trie.put(key_value.first, nil)
+      end
+    end
   end
 
-  EmptySet = Hamster::Set.new
+  EmptySet = Hamster::Set.empty
 end