hamster 1.0.0 → 1.0.1.pre.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a968ce4123ad40d563b7db0aa56b2b64b633c484
-  data.tar.gz: c2447b5cc66229a4f0020f406a2c576759bf8392
+  metadata.gz: 7a6d9d9d40fec03b2572ac9d6357672168a92beb
+  data.tar.gz: 3cb07caf01439c766a95e1e95191df5385e71fc1
 SHA512:
-  metadata.gz: dbf628e0bc57eecb1114bc1079ec4275042ffc8c960407a4431b4abafeb968c354e1ff66eb753dc0bc22f976484f073b61bbbaceb7fd988706bf487f52c77982
-  data.tar.gz: 711c88053c81c50a6ba25eb5c5e3fb8eed58f7faff38f0f6146e86a55240e6606c4dcfd73957acda560b780df8763c9fb3bc2cb66616483257dc3d0461fa7cb2
+  metadata.gz: 3b7b5121f99a8d3cb4d1c749b29c8207b902ca37f1065538b5890f4acf5c647d40bb21900ab50a48979c9abab6efe2dddc2269874dc9e7db44d5aaa6ab9d22fb
+  data.tar.gz: 4fb92d1cbe3e221476930d7e20585acf9ebd53cb6892c4157667a6e1d3402c90804bfebe28f41d69577026d7904f266eb34dae94d41e42f2cf962757c5cecebb

data/lib/hamster.rb

@@ -1,11 +1,10 @@
 require "hamster/core_ext"
 require "hamster/immutable"
 require "hamster/list"
-require "hamster/deque"
+require "hamster/stack"
+require "hamster/queue"
 require "hamster/hash"
 require "hamster/set"
 require "hamster/vector"
-require "hamster/sorted_set"
 require "hamster/mutable_hash"
-require "hamster/nested"
 require "hamster/version"

data/lib/hamster/core_ext.rb

@@ -1,2 +1,3 @@
 require "hamster/core_ext/enumerable"
+require "hamster/core_ext/enumerator"
 require "hamster/core_ext/io"

data/lib/hamster/core_ext/enumerable.rb

@@ -1,21 +1,21 @@
 require "hamster/list"
 
-# Ruby's built-in `Enumerable` module.
-# @see http://www.ruby-doc.org/core/Enumerable.html
-module Enumerable
-  # Return a new {Hamster::List} populated with the items in this `Enumerable` object.
-  # @return [List]
-  def to_list
-    # use destructive operations to build up a new list, like Common Lisp's NCONC
-    # this is a very fast way to build up a linked list
-    list = tail = Hamster::Cons.allocate
-    each do |item|
-      new_node = Hamster::Cons.allocate
-      new_node.instance_variable_set(:@head, item)
-      tail.instance_variable_set(:@tail, new_node)
-      tail = new_node
+module Hamster
+  module CoreExt
+    module Enumerable
+      def self.included(base)
+        base.class_eval do
+          def to_list
+            list = EmptyList
+            reverse_each { |item| list = list.cons(item) }
+            list
+          end
+        end
+      end
     end
-    tail.instance_variable_set(:@tail, Hamster::EmptyList)
-    list.tail
   end
-end
+end
+
+module Enumerable
+  include Hamster::CoreExt::Enumerable
+end

data/lib/hamster/core_ext/enumerator.rb

@@ -0,0 +1,16 @@
+require "hamster/list"
+
+module Hamster
+  module CoreExt
+    module Enumerator
+      # @deprecated Please use Hamster#enumerate instead
+      def to_list
+        Hamster.enumerate(self)
+      end
+    end
+  end
+end
+
+class Enumerator
+  include Hamster::CoreExt::Enumerator
+end

data/lib/hamster/core_ext/io.rb

@@ -1,21 +1,23 @@
 require "hamster/list"
+require "English"
 
-# Ruby's built-in `IO` class.
-# @see http://www.ruby-doc.org/core/IO.html
-class IO
-  # Return a lazy list of "records" read from this IO stream.
-  # "Records" are delimited by `$/`, the global input record separator string.
-  # By default, it is `"\n"`, a newline.
-  #
-  # @return [List]
-  def to_list(sep = $/) # global input record separator
-    Hamster::LazyList.new do
-      line = gets(sep)
-      if line
-        Hamster::Cons.new(line, to_list)
-      else
-        EmptyList
+module Hamster
+  module CoreExt
+    module IO
+      def to_list(sep = $INPUT_RECORD_SEPARATOR)
+        Stream.new do
+          line = gets(sep)
+          if line
+            Sequence.new(line, to_list)
+          else
+            EmptyList
+          end
+        end
       end
     end
   end
 end
+
+class IO
+  include Hamster::CoreExt::IO
+end

data/lib/hamster/enumerable.rb

@@ -1,152 +1,136 @@
+require "forwardable"
+require "hamster/undefined"
+require "hamster/tuple"
+
 module Hamster
-  # Helper module for Hamster's sequential collections
-  #
-  # Classes including `Hamster::Enumerable` must implement:
-  #
-  # - `#each` (just like `::Enumerable`).
-  # - `#select`, which takes a block, and returns an instance of the same class
-  #     with only the items for which the block returns a true value
-  #
   module Enumerable
-    include ::Enumerable
+    extend Forwardable
 
-    # Return a new collection with all the elements for which the block returns false.
-    def reject
-      return enum_for(:reject) if not block_given?
-      select { |item| !yield(item) }
+    def each
+      fail NoMethodError, "undefined method `each' for #{self.class.name}"
     end
-    alias :delete_if :reject
+    def_delegator :self, :each, :foreach
 
-    # Return a new collection with all `nil` elements removed.
-    def compact
-      select { |item| !item.nil? }
+    def filter
+      fail NoMethodError, "undefined method `filter' for #{self.class.name}"
     end
+    def_delegator :self, :filter, :select
+    def_delegator :self, :filter, :find_all
 
-    # Search the collection for elements which are `#===` to `item`. Yield them to
-    # the optional code block if provided, and return them as a new collection.
-    def grep(pattern, &block)
-      result = select { |item| pattern === item }
-      result = result.map(&block) if block_given?
-      result
+    def each_with_index(&block)
+      return self unless block_given?
+      reduce(0) do |index, item|
+        yield(item, index)
+        index + 1
+      end
+      nil
     end
 
-    # Yield all integers from 0 up to, but not including, the number of items in
-    # this collection. For collections which provide indexed access, these are all
-    # the valid, non-negative indices into the collection.
-    def each_index(&block)
-      return enum_for(:each_index) unless block_given?
-      0.upto(size-1, &block)
-      self
+    def reduce(memo = Undefined)
+      each do |item|
+        memo = memo.equal?(Undefined) ? item : yield(memo, item)
+      end if block_given?
+      Undefined.erase(memo)
     end
+    def_delegator :self, :reduce, :inject
+    def_delegator :self, :reduce, :fold
+    def_delegator :self, :reduce, :foldr
 
-    # Multiply all the items (presumably numeric) in this collection together.
-    def product
-      reduce(1, &:*)
+    def partition(&block)
+      return self unless block_given?
+      Tuple.new(filter(&block), remove(&block))
     end
 
-    # Add up all the items (presumably numeric) in this collection.
-    def sum
-      reduce(0, &:+)
+    def find
+      return nil unless block_given?
+      each { |item| return item if yield(item) }
     end
+    def_delegator :self, :find, :detect
 
-    # Return 2 collections, the first containing all the elements for which the block
-    # evaluates to true, the second containing the rest.
-    def partition
-      return enum_for(:partition) if not block_given?
-      a,b = super
-      [self.class.new(a), self.class.new(b)].freeze
-    end
-
-    # Groups the collection into sub-collections by the result of yielding them to
-    # the block. Returns a {Hash} where the keys are return values from the block,
-    # and the values are sub-collections. All the sub-collections are built up from
-    # `empty_group`, which should respond to `#add` by returning a new collection
-    # with an added element.
-    def group_by_with(empty_group, &block)
-      block ||= lambda { |item| item }
-      reduce(EmptyHash) do |hash, item|
-        key = block.call(item)
-        group = hash.get(key) || empty_group
-        hash.put(key, group.add(item))
-      end
+    def include?(object)
+      any? { |item| item == object }
     end
-    protected :group_by_with
-
-    # Groups the collection into sub-collections by the result of yielding them to
-    # the block. Returns a {Hash} where the keys are return values from the block,
-    # and the values are sub-collections (of the same type as this one).
-    def group_by(&block)
-      group_by_with(self.class.empty, &block)
-    end
-
-    # Compare with `other`, and return 0, 1, or -1 if it is (respectively) equal to,
-    # greater than, or less than this collection.
-    def <=>(other)
-      return 0 if self.equal?(other)
-      enum1, enum2 = self.to_enum, other.to_enum
-      loop do
-        item1 = enum1.next
-        item2 = enum2.next
-        comp  = (item1 <=> item2)
-        return comp if comp != 0
-      end
-      size1, size2 = self.size, other.size
-      return 0 if size1 == size2
-      size1 > size2 ? 1 : -1
-    end
-
-    # Return true if `other` contains the same elements, in the same order.
-    # @return [Boolean]
-    def ==(other)
-      self.eql?(other) || other.respond_to?(:to_ary) && to_ary.eql?(other.to_ary)
-    end
-
-    # Convert all the elements into strings and join them together, separated by
-    # `separator`. By default, the `separator` is `$,`, the global default string
-    # separator, which is normally `nil`.
-    def join(separator = $,)
-      result = ""
-      if separator
-        each_with_index { |obj, i| result << separator if i > 0; result << obj.to_s }
-      else
-        each { |obj| result << obj.to_s }
-      end
-      result
+    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
+    def_delegator :self, :any?, :exist?
+    def_delegator :self, :any?, :exists?
 
-    # Convert this collection to a {Set}.
-    def to_set
-      Set.new(self)
+    def all?
+      return all? { |item| item } unless block_given?
+      each { |item| return false unless yield(item) }
+      true
     end
+    def_delegator :self, :all?, :forall?
 
-    # Convert this collection to a programmer-readable `String` representation.
-    def inspect
-      result = "#{self.class}["
-      each_with_index { |obj, i| result << ', ' if i > 0; result << obj.inspect }
-      result << "]"
+    def none?
+      return none? { |item| item } unless block_given?
+      each { |item| return false if yield(item) }
+      true
     end
 
-    # @private
-    def pretty_print(pp)
-      pp.group(1, "#{self.class}[", "]") do
-        pp.breakable ''
-        pp.seplist(self) { |obj| obj.pretty_print(pp) }
+    def one?
+      return one? { |item| !!item } unless block_given?
+      reduce(false) do |previously_matched, item|
+        if yield(item)
+          return false if previously_matched
+          true
+        else
+          previously_matched
+        end
       end
     end
 
-    alias :to_ary :to_a
-    alias :index :find_index
+    def minimum(&block)
+      return minimum { |minimum, item| item <=> minimum } unless block_given?
+      reduce { |minimum, item| yield(minimum, item) < 0 ? item : minimum }
+    end
+    def_delegator :self, :minimum, :min
 
-    ## Compatibility fixes
+    def maximum(&block)
+      return maximum { |maximum, item| item <=> maximum } unless block_given?
+      reduce { |maximum, item| yield(maximum, item) > 0 ? item : maximum }
+    end
+    def_delegator :self, :maximum, :max
 
-    if RUBY_ENGINE == 'rbx'
-      # Rubinius implements Enumerable#sort_by using Enumerable#map
-      # Because we do our own, custom implementations of #map, that doesn't work well
-      # @private
-      def sort_by(&block)
-        result = to_a
-        result.frozen? ? result.sort_by(&block) : result.sort_by!(&block)
-      end
+    def grep(pattern, &block)
+      filter { |item| pattern === item  }.map(&block)
+    end
+
+    def count(&block)
+      return size unless block_given?
+      reduce(0) { |count, item| yield(item) ? count + 1 : count }
+    end
+
+    def product
+      reduce(1, &:*)
+    end
+
+    def sum
+      reduce(0, &:+)
+    end
+
+    def remove
+      return self unless block_given?
+      filter { |item| !yield(item) }
+    end
+    def_delegator :self, :remove, :reject
+    def_delegator :self, :remove, :delete_if
+
+    def compact
+      remove(&:nil?)
+    end
+
+    def to_a
+      reduce([]) { |a, item| a << item }
     end
+    def_delegator :self, :to_a, :entries
+    def_delegator :self, :to_a, :to_ary
   end
-end
+end

data/lib/hamster/experimental/mutable_queue.rb

@@ -1,17 +1,21 @@
-require "hamster/deque"
+require "forwardable"
+require "hamster/queue"
 require "hamster/read_copy_update"
 
 module Hamster
   def self.mutable_queue(*items)
-    MutableQueue.new(deque(*items))
+    MutableQueue.new(queue(*items))
   end
 
   class MutableQueue
+    extend Forwardable
     include ReadCopyUpdate
 
     def enqueue(item)
       transform { |queue| queue.enqueue(item) }
     end
+    def_delegate :self, :enqueue, :<<
+    def_delegate :self, :enqueue, :add
 
     def dequeue
       head = nil

data/lib/hamster/experimental/mutable_set.rb

@@ -1,3 +1,4 @@
+require "forwardable"
 require "hamster/set"
 require "hamster/read_copy_update"
 
@@ -7,12 +8,13 @@ module Hamster
   end
 
   class MutableSet
+    extend Forwardable
     include ReadCopyUpdate
 
     def add(item)
       transform { |set| set.add(item) }
     end
-    alias :<< :add
+    def_delegator :self, :add, :<<
 
     def add?(item)
       added = false

data/lib/hamster/experimental/mutable_stack.rb

@@ -0,0 +1,30 @@
+require "forwardable"
+require "hamster/stack"
+require "hamster/read_copy_update"
+
+module Hamster
+  def self.mutable_stack(*items)
+    MutableStack.new(stack(*items))
+  end
+
+  class MutableStack
+    extend Forwardable
+    include ReadCopyUpdate
+
+    def push(item)
+      transform { |stack| stack.push(item) }
+    end
+    def_delegator :self, :push, :<<
+    def_delegator :self, :push, :enqueue
+
+    def pop
+      top = nil
+      transform do |stack|
+        top = stack.peek
+        stack.pop
+      end
+      top
+    end
+    def_delegator :self, :pop, :dequeue
+  end
+end