immutable 0.2.0 → 0.3.0

data/lib/immutable/map.rb

@@ -1,4 +1,4 @@
-require "immutable/foldable"
+require_relative "foldable"
 
 module Immutable
   # +Immutable::Map+ represents an immutable map from keys to
@@ -133,12 +133,10 @@ module Immutable
       attr_reader :left, :key, :value, :right
 
       def initialize(left, key, value, right)
-        @left, @key, @value, @right = left, key, value, right
-      end
-
-      def self.extract(val)
-        accept_self_instance_only(val)
-        [val.left, val.key, val.value, val.right]
+        @left = left
+        @key = key
+        @value = value
+        @right = right
       end
 
       class << self
@@ -150,12 +148,13 @@ module Immutable
       end
 
       def [](key)
-        if key < self.key
-          left[key]
-        elsif key > self.key
-          right[key]
+        x = key <=> @key
+        if x < 0
+          @left[key]
+        elsif x > 0
+          @right[key]
         else
-          value
+          @value
         end
       end
 
@@ -342,12 +341,13 @@ module Immutable
       end
 
       def ins(key, value)
-        if key < self.key
-          RedFork[left.ins(key, value), self.key, self.value, right]
-        elsif key > self.key
-          RedFork[left, self.key, self.value, right.ins(key, value)]
+        x = key <=> @key
+        if x < 0
+          RedFork[@left.ins(key, value), @key, @value, @right]
+        elsif x > 0
+          RedFork[@left, @key, @value, @right.ins(key, value)]
         else
-          RedFork[left, key, value, right]
+          RedFork[@left, key, value, @right]
         end
       end
     end
@@ -370,12 +370,13 @@ module Immutable
       end
 
       def ins(key, value)
-        if key < self.key
-          balance(left.ins(key, value), self.key, self.value, right)
-        elsif key > self.key
-          balance(left, self.key, self.value, right.ins(key, value))
+        x = key <=> @key
+        if x < 0
+          balance(@left.ins(key, value), @key, @value, @right)
+        elsif x > 0
+          balance(@left, @key, @value, @right.ins(key, value))
         else
-          BlackFork[left, key, value, right]
+          BlackFork[@left, key, value, @right]
         end
       end
     end

data/lib/immutable/output_restricted_deque.rb

@@ -0,0 +1,20 @@
+require_relative "queue"
+
+module Immutable
+  # +Immutable::OutputRestrictedDeque+ is an implementation of
+  # output-restricted deques described in "Purely Functional Data
+  # Structures" by Chris Okasaki.
+  class OutputRestrictedDeque < Queue
+    include Consable
+
+    # Adds a new element at the head of +self+.
+    #
+    # @param [Object] x the element to add.
+    # @return [Queue] a new queue.
+    def cons(x)
+      self.class.new(Stream.cons(->{x}, ->{@front}), @rear,
+                     Stream.cons(->{x}, ->{@schedule}))
+    end
+    alias prepend cons
+  end
+end

data/lib/immutable/queue.rb

@@ -1,10 +1,10 @@
-require "immutable/stream"
+require_relative "stream"
 
 module Immutable
   # +Immutable::Queue+ is an implementation of real-time queues described in
   # "Purely Functional Data Structures" by Chris Okasaki.
   class Queue
-    include Enumerable
+    include Headable
 
     # +Queue.new+ is for internal use only. Use {Queue.empty} or {Queue.[]}
     # instead.
@@ -18,13 +18,13 @@ module Immutable
     #
     # @return [Queue] the empty queue.
     def self.empty
-      Queue.new(Stream.null, Nil, Stream.null)
+      new(Stream.empty, Nil, Stream.empty)
     end
 
     # Creates a new queue populated with the given objects.
     #
     # @param [Array<Object>] elements the elements of the queue.
-    # @return [List] the new queue.
+    # @return [Queue] the new queue.
     def self.[](*elements)
       elements.inject(empty, &:snoc)
     end
@@ -33,33 +33,9 @@ module Immutable
     #
     # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
     def empty?
-      @front.null?
+      @front.empty?
     end
 
-    def rotate(front, rear, accumulator)
-      Stream.lazy {
-        if front.null?
-          Stream.cons(->{rear.head}, ->{accumulator})
-        else
-          Stream.cons(->{front.head}, ->{
-            rotate(front.tail, rear.tail,
-                   Stream.cons(->{rear.head}, ->{accumulator}))
-          })
-        end
-      }
-    end
-    private :rotate
-
-    def queue(front, rear, schedule)
-      if schedule.null?
-        f = rotate(front, rear, Stream.null)
-        Queue.new(f, Nil, f)
-      else
-        Queue.new(front, rear, schedule.tail)
-      end
-    end
-    private :queue
-
     # Adds a new element at the end of +self+.
     #
     # @param [Object] x the element to add.
@@ -67,10 +43,11 @@ module Immutable
     def snoc(x)
       queue(@front, Cons[x, @rear], @schedule)
     end
+
     alias push snoc
 
     # Returns the first element of +self+. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
+    # +Immutable::EmptyError+ is raised.
     #
     # @return [Object] the first element of +self+.
     def head
@@ -78,22 +55,38 @@ module Immutable
     end
 
     # Returns the elements after the head of +self+. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
+    # +Immutable::EmptyError+ is raised.
     #
     # @return [Queue] the elements after the head of +self+.
     def tail
-      if @front.null?
-        raise List::EmptyError
+      if @front.empty?
+        raise EmptyError
       else
         queue(@front.tail, @rear, @schedule)
       end
     end
 
-    # Calls +block+ once for each element in +self+.
-    def each(&block)
-      unless @front.null?
-        yield(head)
-        tail.each(&block)
+    private
+
+    def rotate(front, rear, accumulator)
+      Stream.lazy {
+        if front.empty?
+          Stream.cons(->{rear.head}, ->{accumulator})
+        else
+          Stream.cons(->{front.head}, ->{
+            rotate(front.tail, rear.tail,
+                   Stream.cons(->{rear.head}, ->{accumulator}))
+          })
+        end
+      }
+    end
+
+    def queue(front, rear, schedule)
+      if schedule.empty?
+        f = rotate(front, rear, Stream.empty)
+        self.class.new(f, Nil, f)
+      else
+        self.class.new(front, rear, schedule.tail)
       end
     end
   end

data/lib/immutable/stream.rb

@@ -1,6 +1,5 @@
-require "immutable/foldable"
-require "immutable/list"
-require "immutable/promise"
+require_relative "list"
+require_relative "promise"
 
 module Immutable
   # +Immutable::Stream+ represents a stream, also known as a lazy list.
@@ -22,17 +21,16 @@ module Immutable
   #   }
   #   p primes.take_while { |n| n < 10 }.to_list #=> List[2, 3, 5, 7]
   class Stream < Promise
-    include Enumerable
-    include Foldable
+    include Consable
 
     NULL = Object.new
 
     def NULL.head
-      raise List::EmptyError
+      raise EmptyError
     end
 
     def NULL.tail
-      raise List::EmptyError
+      raise EmptyError
     end
 
     def NULL.inspect
@@ -51,18 +49,18 @@ module Immutable
     # Returns an empty stream.
     #
     # @return [Stream] an empty stream.
-    def self.null
+    def self.empty
       delay { NULL }
     end
 
     # Creates a new stream.
     #
     # @example A Stream which has 123 as the only element.
-    #   s = Stream.cons(->{123}, ->{Stream.null})
+    #   s = Stream.cons(->{123}, ->{Stream.empty})
     #   p s.to_list #=> List[123]
     # @example A Stream which has two elements: "abc" and "def".
     #   s = Stream.cons(->{"abc"},
-    #         ->{Stream.cons(->{"def"}, ->{Stream.null})})
+    #         ->{Stream.cons(->{"def"}, ->{Stream.empty})})
     #   p s.to_list #=> List["abc", "def"]
     #
     # @param [Proc] head a +Proc+ whose value is the head of +self+.
@@ -72,19 +70,23 @@ module Immutable
       Stream.eager(Pair.new(Stream.delay(&head), Stream.lazy(&tail)))
     end
 
-    # Creates a new stream whose head is the value of +block+ and whose tail
-    # is +self+.
+    # Creates a new stream whose head is the value of +x+ or +block+ and
+    # whose tail is +self+.
     #
     # @example A Stream which has 123 as the only element.
-    #   s = Stream.null.prepend {123}
+    #   s = Stream.empty.cons(123)
     #   p s.to_list #=> List[123]
     # @example A Stream which has two elements: "abc" and "def".
-    #   s = Stream.null.prepend {"def"}.prepend {"abc"}
+    #   s = Stream.empty.cons {"def"}.cons {"abc"}
     #   p s.to_list #=> List["abc", "def"]
     #
     # @return [Stream] the new stream.
-    def prepend(&block)
-      Stream.eager(Pair.new(Stream.delay(&block), self))
+    def cons(x = nil, &block)
+      if block
+        Stream.eager(Pair.new(Stream.delay(&block), self))
+      else
+        Stream.eager(Pair.new(Stream.eager(x), self))
+      end
     end
 
     # Creates a new stream. Note that the arguments are evaluated eagerly.
@@ -115,7 +117,7 @@ module Immutable
           x = e.next
           cons ->{ x }, ->{ from_enumerator(e) }
         rescue StopIteration
-          null
+          empty
         end
       }
     end
@@ -133,26 +135,24 @@ module Immutable
     # Returns whether +self+ is empty.
     #
     # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
-    def null?
+    def empty?
       force == NULL
     end
-    alias empty? null?
 
     # Returns the first element of +self+. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
+    # +Immutable::EmptyError+ is raised.
     #
     # @return [Object] the first element of +self+.
     def head
       force.head.force
     end
-    alias first head
 
     # Returns the last element of +self+. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
+    # +Immutable::EmptyError+ is raised.
     #
     # @return [Object] the last element of +self+.
     def last
-      if tail.null?
+      if tail.empty?
         head
       else
         tail.last
@@ -160,7 +160,7 @@ module Immutable
     end
 
     # Returns the stream stored in the tail of +self+. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
+    # +Immutable::EmptyError+ is raised.
     #
     # @return [Stream] the stream stored in the tail of +self+.
     def tail
@@ -168,17 +168,17 @@ module Immutable
     end
 
     # Returns all the elements of +self+ except the last one.
-    # If +self+ is empty, +Immutable::List::EmptyError+ is
+    # If +self+ is empty, +Immutable::EmptyError+ is
     # raised.
     #
     # @return [Stream] the elements of +self+ except the last one.
     def init
       Stream.lazy {
-        if null?
-          raise List::EmptyError
+        if empty?
+          raise EmptyError
         else
-          if tail.null?
-            Stream.null
+          if tail.empty?
+            Stream.empty
           else
             Stream.cons(->{head}, ->{tail.init})
           end
@@ -195,7 +195,7 @@ module Immutable
 
     def inspect_i(s = nil)
       if eager?
-        if null?
+        if empty?
           s || ""
         else
           h = force.head.eager? ? head.inspect : "?"
@@ -215,88 +215,13 @@ module Immutable
     end
     protected :inspect_i
 
-    # Calls +block+ once for each element in +self+.
-    def each(&block)
-      unless null?
-        yield(head)
-        tail.each(&block)
-      end
-    end
-
-    # Reduces +self+ using +block+ from right to left. +e+ is used as the
-    # starting value. For example:
-    #
-    #   Stream[1, 2, 3].foldr(9) { |x, y| x + y } #=> 1 - (2 - (3 - 9)) = -7
-    #
-    # @param [Object] e the start value.
-    # @return [Object] the reduced value.
-    def foldr(e, &block)
-      if null?
-        e
-      else
-        yield(head, tail.foldr(e, &block))
-      end
-    end
-
-    # Reduces +self+ using +block+ from right to left. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
-    #
-    # @return [Object] the reduced value.
-    def foldr1(&block)
-      if tail.null?
-        head
-      else
-        yield(head, tail.foldr1(&block))
-      end
-    end
-
-    # Reduces +self+ using +block+ from left to right. +e+ is used as the
-    # starting value. For example:
-    #
-    #   Stream[1, 2, 3].foldl(9) { |x, y| x + y } #=> ((9 - 1) - 2) - 3 = 3
-    #
-    # @param [Object] e the start value.
-    # @return [Object] the reduced value.
-    def foldl(e, &block)
-      if null?
-        e
-      else
-        tail.foldl(yield(e, head), &block)
-      end
-    end
-
-    # Reduces +self+ using +block+ from left to right. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
-    #
-    # @return [Object] the reduced value.
-    def foldl1(&block)
-      tail.foldl(head, &block)
-    end
-
-    # Returns whether +self+ equals to +s+.
-    #
-    # @param [Stream] s the stream to compare.
-    # @return [true, false] +true+ if +self+ equals to +s+; otherwise,
-    # +false+.
-    def ==(s)
-      if !s.is_a?(Stream)
-        false
-      else
-        if null?
-          s.null?
-        else
-          !s.null? && head == s.head && tail == s.tail
-        end
-      end
-    end
-
     # Appends two streams +self+ and +s+.
     #
     # @param [Stream] s the stream to append.
     # @return [Stream] the new stream.
     def +(s)
       Stream.lazy {
-        if null?
+        if empty?
           s
         else
           Stream.cons ->{head}, ->{tail + s}
@@ -304,33 +229,14 @@ module Immutable
       }
     end
 
-    # Concatenates a stream of streams.
-    #
-    # @return [Stream] the concatenated stream.
-    def flatten
-      Stream.lazy {
-        if null?
-          self
-        else
-          if head.null?
-            tail.flatten
-          else
-            Stream.cons ->{head.head}, ->{
-              Stream.cons(->{head.tail}, ->{tail}).flatten
-            }
-          end
-        end
-      }
-    end
-
     # Returns the stream obtained by applying the given block to each
     # element in +self+.
     #
     # @return [Stream] the obtained stream.
     def map(&block)
       Stream.lazy {
-        if null?
-          Stream.null
+        if empty?
+          Stream.empty
         else
           Stream.cons ->{ yield(head) }, ->{ tail.map(&block) }
         end
@@ -341,7 +247,7 @@ module Immutable
     #
     # @return [Stream] the reversed stream.
     def reverse
-      foldl(Stream.null) { |x, y| Stream.cons(->{y}, ->{x}) }
+      foldl(Stream.empty) { |x, y| Stream.cons(->{y}, ->{x}) }
     end
 
     # Returns a new stream obtained by inserting +sep+ in between the
@@ -351,7 +257,7 @@ module Immutable
     # @return [Stream] the new stream.
     def intersperse(sep)
       Stream.lazy {
-        if null?
+        if empty?
           self
         else
           Stream.cons(->{head}, ->{tail.prepend_to_all(sep)})
@@ -361,7 +267,7 @@ module Immutable
 
     def prepend_to_all(sep)
       Stream.lazy {
-        if null?
+        if empty?
           self
         else
           Stream.cons ->{sep}, ->{
@@ -383,54 +289,26 @@ module Immutable
       intersperse(xs).flatten
     end
 
-    # Returns the first element in +self+ for which the given block
-    # evaluates to true.  If such an element is not found, it
-    # returns +nil+.
-    #
-    # @return [Object] the found element.
-    def find(&block)
-      if null?
-        nil
-      else
-        if yield(head)
-          head
-        else
-          tail.find(&block)
-        end
-      end
-    end
-
-    # Returns the elements in +self+ for which the given block evaluates to
-    # true.
+    # Concatenates a stream of streams.
     #
-    # @return [Stream] the elements that satisfies the condition.
-    def filter(&block)
+    # @return [Stream] the concatenated stream.
+    def flatten
       Stream.lazy {
-        if null?
-          Stream.null
+        if empty?
+          self
         else
-          if yield(head)
-            Stream.cons ->{ head }, ->{ tail.filter(&block) }
+          if head.empty?
+            tail.flatten
           else
-            tail.filter(&block)
+            Stream.cons ->{head.head}, ->{
+              Stream.cons(->{head.tail}, ->{tail}).flatten
+            }
           end
         end
       }
     end
 
-    # Returns the +n+th element of +self+. If +n+ is out of range, +nil+ is
-    # returned.
-    #
-    # @return [Object] the +n+th element.
-    def [](n)
-      if n < 0 || null?
-        nil
-      elsif n == 0
-        head
-      else
-        tail[n - 1]
-      end
-    end
+    alias concat flatten
 
     # Returns the first +n+ elements of +self+, or +self+ itself if
     # +n > self.length+.
@@ -439,8 +317,8 @@ module Immutable
     # @return [Stream] the first +n+ elements of +self+.
     def take(n)
       Stream.lazy {
-        if n <= 0 || null?
-          Stream.null
+        if n <= 0 || empty?
+          Stream.empty
         else
           Stream.cons ->{ head }, ->{ tail.take(n - 1) }
         end
@@ -454,7 +332,7 @@ module Immutable
     # @return [Stream] the suffix of +self+ after the first +n+ elements.
     def drop(n)
       Stream.lazy {
-        if n <= 0 || null?
+        if n <= 0 || empty?
           self
         else
           tail.drop(n - 1)
@@ -468,8 +346,8 @@ module Immutable
     # @return [Stream] the prefix of the elements of +self+.
     def take_while(&block)
       Stream.lazy {
-        if null? || !yield(head)
-          Stream.null
+        if empty? || !yield(head)
+          Stream.empty
         else
           Stream.cons ->{ head }, ->{ tail.take_while(&block) }
         end
@@ -482,7 +360,7 @@ module Immutable
     # @return [Stream] the suffix of the elements of +self+.
     def drop_while(&block)
       Stream.lazy {
-        if null? || !yield(head)
+        if empty? || !yield(head)
           self
         else
           tail.drop_while(&block)
@@ -490,11 +368,22 @@ module Immutable
       }
     end
 
-    # Converts +self+ to a list.
+    # Returns the elements in +self+ for which the given block evaluates to
+    # true.
     #
-    # @return [List] a list.
-    def to_list
-      foldr(List[]) { |x, xs| Cons[x, xs] }
+    # @return [Stream] the elements that satisfies the condition.
+    def filter(&block)
+      Stream.lazy {
+        if empty?
+          Stream.empty
+        else
+          if yield(head)
+            Stream.cons ->{ head }, ->{ tail.filter(&block) }
+          else
+            tail.filter(&block)
+          end
+        end
+      }
     end
 
     # Builds a stream from the seed value +e+ and the given block. The block
@@ -514,7 +403,7 @@ module Immutable
       Stream.lazy {
         x = yield(e)
         if x.nil?
-          Stream.null
+          Stream.empty
         else
           y, z = x
           Stream.cons ->{ y }, ->{ unfoldr(z, &block) }
@@ -530,11 +419,11 @@ module Immutable
     # @return [Stream] the new stream.
     def zip(*xss)
       Stream.lazy {
-        if null?
+        if empty?
           self
         else
-          heads = xss.map { |xs| xs.null? ? nil : xs.head }
-          tails = xss.map { |xs| xs.null? ? Stream.null : xs.tail }
+          heads = xss.map { |xs| xs.empty? ? nil : xs.head }
+          tails = xss.map { |xs| xs.empty? ? Stream.empty : xs.tail }
           Stream.cons ->{ [head, *heads] }, ->{ tail.zip(*tails) }
         end
       }
@@ -550,11 +439,11 @@ module Immutable
     # @return [Stream] the new stream.
     def zip_with(*xss, &block)
       Stream.lazy {
-        if null?
+        if empty?
           self
         else
-          heads = xss.map { |xs| xs.null? ? nil : xs.head }
-          tails = xss.map { |xs| xs.null? ? Stream.null : xs.tail }
+          heads = xss.map { |xs| xs.empty? ? nil : xs.head }
+          tails = xss.map { |xs| xs.empty? ? Stream.empty : xs.tail }
           h = yield(head, *heads)
           Stream.cons ->{ h }, ->{ tail.zip_with(*tails, &block) }
         end