immutable 0.2.0 → 0.3.0

data/lib/immutable/deque.rb

@@ -0,0 +1,196 @@
+require_relative "stream"
+require_relative "consable"
+
+module Immutable
+  # +Immutable::Deque+ is an implementation of real-time deques described in
+  # "Purely Functional Data Structures" by Chris Okasaki.
+  class Deque
+    include Consable
+
+    # +Deque.new+ is for internal use only. Use {Deque.empty} or {Deque.[]}
+    # instead.
+    def initialize(front, front_len, front_schedule,
+                   rear, rear_len, rear_schedule)
+      @front = front
+      @front_len = front_len
+      @front_schedule = front_schedule
+      @rear = rear
+      @rear_len = rear_len
+      @rear_schedule = rear_schedule
+      @c = 3  # @c should be 2 or 3
+    end
+
+    # Returns an empty deque.
+    #
+    # @return [Deque] the empty deque.
+    def self.empty
+      Deque.new(Stream.empty, 0, Stream.empty,
+                Stream.empty, 0, Stream.empty)
+    end
+
+    # Creates a new deque populated with the given objects.
+    #
+    # @param [Array<Object>] elements the elements of the deque.
+    # @return [Deque] the new deque.
+    def self.[](*elements)
+      elements.inject(empty, &:snoc)
+    end
+
+    # Returns whether +self+ is empty.
+    #
+    # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
+    def empty?
+      length == 0
+    end
+
+    # Returns the number of elements in +self+. May be zero.
+    #
+    # @return [Integer] the number of elements in +self+.
+    def length
+      @front_len + @rear_len
+    end
+
+    # Adds a new element at the head of +self+.
+    #
+    # @param [Object] x the element to add.
+    # @return [Deque] a new deque.
+    def cons(x)
+      queue(Stream.cons(->{x}, ->{@front}), @front_len + 1,
+            exec1(@front_schedule),
+            @rear, @rear_len, exec1(@rear_schedule))
+    end
+
+    # Returns the first element of +self+. If +self+ is empty,
+    # +Immutable::EmptyError+ is raised.
+    #
+    # @return [Object] the first element of +self+.
+    def head
+      if @front.empty?
+        if @rear.empty?
+          raise EmptyError
+        else
+          @rear.head
+        end
+      else
+        @front.head
+      end
+    end
+
+    # Returns the elements after the head of +self+. If +self+ is empty,
+    # +Immutable::EmptyError+ is raised.
+    #
+    # @return [Deque] the elements after the head of +self+.
+    def tail
+      if @front.empty?
+        if @rear.empty?
+          raise EmptyError
+        else
+          self.class.empty
+        end
+      else
+        queue(@front.tail, @front_len - 1, exec2(@front_schedule),
+              @rear, @rear_len, exec2(@rear_schedule))
+      end
+    end
+
+    # Adds a new element at the end of +self+.
+    #
+    # @param [Object] x the element to add.
+    # @return [Deque] a new queue.
+    def snoc(x)
+      queue(@front, @front_len, exec1(@front_schedule),
+            Stream.cons(->{x}, ->{@rear}), @rear_len + 1,
+            exec1(@rear_schedule))
+    end
+
+    alias push snoc
+
+    # Returns the last element of +self+. If +self+ is empty,
+    # +Immutable::EmptyError+ is raised.
+    #
+    # @return [Object] the last element of +self+.
+    def last
+      if @rear.empty?
+        if @front.empty?
+          raise EmptyError
+        else
+          @front.head
+        end
+      else
+        @rear.head
+      end
+    end
+
+    # Returns all the elements of +self+ except the last one.
+    # If +self+ is empty, +Immutable::EmptyError+ is
+    # raised.
+    #
+    # @return [Deque] the elements of +self+ except the last one.
+    def init
+      if @rear.empty?
+        if @front.empty?
+          raise EmptyError
+        else
+          self.class.empty
+        end
+      else
+        queue(@front, @front_len, exec2(@front_schedule),
+              @rear.tail, @rear_len - 1, exec2(@rear_schedule))
+      end
+    end
+
+    alias pop init
+
+    private
+
+    def exec1(s)
+      if s.empty?
+        s
+      else
+        s.tail
+      end
+    end
+
+    def exec2(s)
+      exec1(exec1(s))
+    end
+
+    def rotate_rev(r, f, a)
+      if r.empty?
+        f.reverse + a
+      else
+        Stream.cons(->{r.head},
+                    ->{rotate_rev(r.tail, f.drop(@c),
+                                  f.take(@c).reverse + a)})
+      end
+    end
+
+    def rotate_drop(r, i, f)
+      if i < @c
+        rotate_rev(r, f.drop(i), Stream.empty)
+      else
+        x = r.head
+        r2 = r.tail
+        Stream.cons(->{x}, ->{rotate_drop(r2, i - @c, f.drop(@c))})
+      end
+    end
+
+    def queue(f, f_len, f_schedule, r, r_len, r_schedule)
+      if f_len > @c * r_len + 1
+        i = (f_len + r_len) / 2
+        j = (f_len + r_len) - i
+        f2 = f.take(i)
+        r2 = rotate_drop(r, i, f)
+        self.class.new(f2, i, f2, r2, j, r2)
+      elsif r_len > @c * f_len + 1
+        j = (f_len + r_len) / 2
+        i = (f_len + r_len) - j
+        f2 = rotate_drop(f, j, r)
+        r2 = r.take(j)
+        self.class.new(f2, i, f2, r2, j, r2)
+      else
+        self.class.new(f, f_len, f_schedule, r, r_len, r_schedule)
+      end
+    end
+  end
+end

data/lib/immutable/foldable.rb

@@ -1,5 +1,15 @@
 module Immutable
   module Foldable
+    # Reduces +self+ using +block+ from left to right. +e+ is used as the
+    # starting value. A class including +Immutable::Foldable+ must implement
+    # this method.
+    #
+    # @param [Object] e the start value.
+    # @return [Object] the reduced value.
+    def foldl(e, &block)
+      raise NotImplementedError
+    end
+
     # Returns the number of elements in +self+. May be zero.
     #
     # @return [Integer] the number of elements in +self+.

data/lib/immutable/headable.rb

@@ -0,0 +1,235 @@
+require_relative "foldable"
+
+module Immutable
+  class EmptyError < StandardError
+    def initialize(msg = "collection is empty")
+      super(msg)
+    end
+  end
+
+  module Headable
+    include Enumerable
+    include Foldable
+
+    # Returns the first element of +self+. If +self+ is empty,
+    # +Immutable::EmptyError+ is raised. A class including
+    # +Immutable::Headable+ must implement this method.
+    #
+    # @return [Object] the first element of +self+.
+    def head
+      raise NotImplementedError
+    end
+
+    # Same as {#head}. This method just calls {#head}.
+    #
+    # @return [Object] the first element of +self+.
+    def first
+      head
+    end
+
+    # Returns the elements after the head of +self+. If +self+ is empty,
+    # +Immutable::EmptyError+ is raised. A class including
+    # +Immutable::Headable+ must implement this method.
+    #
+    # @return [Headable] the elements after the head of +self+.
+    def tail
+      raise NotImplementedError
+    end
+
+    # Same as {#tail}. This method just calls {#tail}.
+    #
+    # @return [Headable] the elements after the head of +self+.
+    def shift
+      tail
+    end
+
+    # Returns whether +self+ is empty. A class including
+    # +Immutable::Headable+ must implement this method.
+    #
+    # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
+    def empty?
+      raise NotImplementedError
+    end
+
+    # Same as {#empty?}. This method just calls {#empty?}.
+    #
+    # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
+    def null?
+      empty?
+    end
+
+    # Returns a string containing a human-readable representation of +self+.
+    # 
+    # @return [String] a string representation of +self+.
+    def inspect
+      if empty?
+        class_name + "[]"
+      else
+        class_name + "[" + head.inspect +
+          tail.foldl("") {|x, y| x + ", " + y.inspect } + "]"
+      end
+    end
+
+    # Returns whether +self+ equals to +x+.
+    #
+    # @param [Object] x the object to compare.
+    # @return [true, false] +true+ if +self+ equals to +x+; otherwise,
+    #   +false+.
+    def ==(x)
+      if !x.is_a?(self.class)
+        false
+      else
+        if empty?
+          x.empty?
+        else
+          !x.empty? && head == x.head && tail == x.tail
+        end
+      end
+    end
+
+    def eql?(x)
+      if !x.is_a?(self.class)
+        false
+      else
+        if empty?
+          x.empty?
+        else
+          !x.empty? && head.eql?(x.head) && tail.eql?(x.tail)
+        end
+      end
+    end
+    
+    # @return [Integer]
+    def hash
+      to_a.hash
+    end
+
+    # Calls +block+ once for each element in +self+.
+    # @yield [element]
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each(&block)
+      return to_enum unless block_given?
+  
+      unless empty?
+        yield(head)
+        tail.each(&block)
+      end
+      
+      self
+    end
+
+    # Reduces +self+ using +block+ from right to left. +e+ is used as the
+    # starting value. For example:
+    #
+    #   List[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 empty?
+        e
+      else
+        yield(head, tail.foldr(e, &block))
+      end
+    end
+
+    # Reduces +self+ using +block+ from right to left. If +self+ is empty,
+    # +Immutable::EmptyError+ is raised.
+    #
+    # @return [Object] the reduced value.
+    def foldr1(&block)
+      if empty?
+        raise EmptyError
+      else
+        if tail.empty?
+          head
+        else
+          yield(head, tail.foldr1(&block))
+        end
+      end
+    end
+
+    # Reduces +self+ using +block+ from left to right. +e+ is used as the
+    # starting value. For example:
+    #
+    #   List[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 empty?
+        e
+      else
+        tail.foldl(yield(e, head), &block)
+      end
+    end
+
+    # Reduces +self+ using +block+ from left to right. If +self+ is empty,
+    # +Immutable::EmptyError+ is raised.
+    #
+    # @return [Object] the reduced value.
+    def foldl1(&block)
+      if empty?
+        raise EmptyError
+      else
+        tail.foldl(head, &block)
+      end
+    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+.
+    #
+    # @param [#call, nil] ifnone
+    # @yield [element]
+    # @yieldreturn [Object] the found element.
+    # @return [Enumerator]
+    def find(ifnone=nil, &block)
+      return to_enum(__callee__, ifnone) unless block_given?
+
+      if empty?
+        if ifnone.nil?
+          nil
+        else
+          ifnone.call
+        end
+      else
+        if yield(head)
+          head
+        else
+          tail.find(ifnone, &block)
+        end
+      end
+    end
+    
+    alias detect find
+
+    # 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 || empty?
+        nil
+      elsif n == 0
+        head
+      else
+        tail[n - 1]
+      end
+    end
+
+    # Converts +self+ to a list.
+    #
+    # @return [List] a list.
+    def to_list
+      foldr(List[]) { |x, xs| Cons[x, xs] }
+    end
+ 
+    private
+
+    def class_name
+      self.class.name.slice(/[^:]*\z/)
+    end
+  end
+end

data/lib/immutable/list.rb

@@ -1,4 +1,4 @@
-require "immutable/foldable"
+require_relative "consable"
 
 module Immutable
   # +Immutable::List+ represents an immutable list.
@@ -18,82 +18,33 @@ module Immutable
   #   p Nil                    #=> List[]
   #   p Cons[1, Cons[2, Nil]]  #=> List[1, 2]
   class List
-    include Enumerable
-    include Foldable
+    include Consable
 
-    class EmptyError < StandardError
-      def initialize(msg = "list is empty")
-        super(msg)
-      end
-    end
-
-    # Creates a new list populated with the given objects.
-    #
-    # @param [Array<Object>] elements the elements of the list.
-    # @return [List] the new list.
-    def self.[](*elements)
-      from_array(elements)
-    end
-
-    # Converts the given array to a list.
-    #
-    # @param [Array, #reverse_each] ary the array to convert.
-    # @return [List] the list converted from +ary+.
-    def self.from_array(ary)
-      ary.reverse_each.inject(Nil) { |x, y|
-        Cons.new(y, x)
-      }
-    end
-
-    # Converts the given Enumerable object to a list.
-    #
-    # @param [#inject] enum the Enumerable object to convert.
-    # @return [List] the list converted from +enum+.
-    def self.from_enum(enum)
-      enum.inject(Nil) { |x, y|
-        Cons.new(y, x)
-      }.reverse
-    end
-
-    # Calls +block+ once for each element in +self+.
-    def each(&block)
-    end
-
-    # Appends two lists +self+ and +xs+.
+    # Returns an empty list.
     #
-    # @param [List] xs the list to append.
-    # @return [List] the new list.
-    def +(xs)
-      foldr(xs) { |y, ys| Cons[y, ys] }
+    # @return [list] the empty list.
+    def self.empty
+      Nil
     end
 
-    # Returns whether +self+ equals to +xs+.
+    # Adds a new element at the head of +self+.
     #
-    # @param [List] xs the list to compare.
-    # @return [true, false] +true+ if +self+ equals to +xs+; otherwise,
-    # +false+.
-    def ==(xs)
-      # this method should be overriden
+    # @param [Object] x the element to add.
+    # @return [List] a new list.
+    def cons(x)
+      Cons[x, self]
     end
 
     # 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
       # this method should be overriden
     end
 
-    # Returns the first element of +self+. If +self+ is empty,
-    # +Immutable::List::EmptyError+ is raised.
-    #
-    # @return [Object] the first element of +self+.
-    def first
-      head
-    end
-
     # 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
@@ -101,7 +52,7 @@ 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 [List] the elements after the head of +self+.
     def tail
@@ -109,7 +60,7 @@ 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 [List] the elements of +self+ except the last one.
@@ -117,193 +68,17 @@ module Immutable
       # this method should be overriden
     end
 
-    # Returns whether +self+ is empty.
+    # Same as {#init}.
     #
-    # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
-    def empty?
-      # this method should be overriden
+    # @return [List] the elements of +self+ except the last one.
+    def pop
+      init
     end
 
     # Returns whether +self+ is empty.
     #
     # @return [true, false] +true+ if +self+ is empty; otherwise, +false+.
-    def null?
-      empty?
-    end
-
-    # Returns the list obtained by applying the given block to each element
-    # in +self+.
-    #
-    # @return [List] the obtained list.
-    def map
-      foldr(Nil) { |x, xs| Cons[yield(x), xs] }
-    end
-
-    # Returns the elements of +self+ in reverse order.
-    #
-    # @return [List] the reversed list.
-    def reverse
-      foldl(Nil) { |x, y| Cons[y, x] }
-    end
-
-    # Returns a new list obtained by inserting +sep+ in between the elements
-    # of +self+.
-    #
-    # @param [Object] sep the object to insert between elements.
-    # @return [List] the new list.
-    def intersperse(sep)
-      # this method should be overriden
-    end
-
-    # Returns a new list obtained by inserting +xs+ in between the lists in
-    # +self+ and concatenates the result.
-    # +xss.intercalate(xs)+ is equivalent to
-    # +xss.intersperse(xs).flatten+.
-    #
-    # @param [List] xs the list to insert between lists.
-    # @return [List] the new list.
-    def intercalate(xs)
-      intersperse(xs).flatten
-    end
-
-    # Transposes the rows and columns of +self+. For example:
-    # 
-    #   p List[List[1, 2, 3], List[4, 5, 6]].transpose
-    #   #=> List[List[1, 4], List[2, 5], List[3, 6]]
-    #
-    # @return [List] the transposed list.
-    def transpose
-      # this method should be overriden
-    end
-
-    # Returns the list of all subsequences of +self+.
-    #
-    # @return [List<List>] the list of subsequences.
-    def subsequences
-      Cons[List[], nonempty_subsequences]
-    end
-
-    # Reduces +self+ using +block+ from right to left. +e+ is used as the
-    # starting value. For example:
-    #
-    #   List[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)
-      # this method should be overriden
-    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)
-      # this method should be overriden
-    end
-
-    # Reduces +self+ using +block+ from left to right. +e+ is used as the
-    # starting value. For example:
-    #
-    #   List[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)
-      # this method should be overriden
-    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)
-      # this method should be overriden
-    end
-
-    # Concatenates a list of lists.
-    #
-    # @return [List] the concatenated list.
-    def flatten
-      foldr(Nil) { |x, xs| x + xs }
-    end
-
-    alias concat flatten
-
-    # Returns the list obtained by concatenating the results of the given
-    # block for each element in +self+.
-    #
-    # @return [List] the obtained list.
-    def flat_map
-      foldr(Nil) { |x, xs| yield(x) + xs }
-    end
-
-    alias concat_map flat_map
-
-    alias bind flat_map
-
-    # Builds a list from the seed value +e+ and the given block. The block
-    # takes a seed value and returns +nil+ if the seed should
-    # unfold to the empty list, or returns +[a, b]+, where
-    # +a+ is the head of the list and +b+ is the next
-    # seed from which to unfold the tail.  For example:
-    #
-    #   xs = List.unfoldr(3) { |x| x == 0 ? nil : [x, x - 1] }
-    #   p xs #=> List[3, 2, 1]
-    #
-    # +unfoldr+ is the dual of +foldr+.
-    #
-    # @param [Object] e the seed value.
-    # @return [List] the list built from the seed value and the block.
-    def self.unfoldr(e, &block)
-      x = yield(e)
-      if x.nil?
-        Nil
-      else
-        y, z = x
-        Cons[y, unfoldr(z, &block)]
-      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)
-      # this method should be overriden
-    end
-
-    # Returns the first +n+ elements of +self+, or all the elements of
-    # +self+ if +n > self.length+.
-    #
-    # @param [Integer] n the number of elements to take.
-    # @return [List] the first +n+ elements of +self+.
-    def take(n)
-      # this method should be overriden
-    end
-
-    # Returns the suffix of +self+ after the first +n+ elements, or
-    # +List[]+ if +n > self.length+.
-    #
-    # @param [Integer] n the number of elements to drop.
-    # @return [List] the suffix of +self+ after the first +n+ elements.
-    def drop(n)
-      # this method should be overriden
-    end
-
-    # Returns the longest prefix of the elements of +self+ for which +block+
-    # evaluates to true.
-    #
-    # @return [List] the prefix of the elements of +self+.
-    def take_while(&block)
-      # this method should be overriden
-    end
-
-    # Returns the suffix remaining after
-    # +self.take_while(&block)+.
-    #
-    # @return [List] the suffix of the elements of +self+.
-    def drop_while(&block)
+    def empty?
       # this method should be overriden
     end
 
@@ -314,49 +89,10 @@ module Immutable
       self
     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)
-      # this method should be overriden
-    end
-
-    # Returns the elements in +self+ for which the given block evaluates to
-    # true.
-    #
-    # @return [List] the elements that satisfies the condition.
-    def filter
-      foldr(Nil) { |x, xs|
-        if yield(x)
-          Cons[x, xs]
-        else
-          xs
-        end
-      }
-    end
+    private
 
-    # Takes zero or more lists and returns a new list in which each element
-    # is an array of the corresponding elements of +self+ and the input
-    # lists.
-    #
-    # @param [Array<List>] xss the input lists.
-    # @return [List] the new list.
-    def zip(*xss)
-      # this method should be overriden
-    end
-
-    # Takes zero or more lists and returns the list obtained by applying the
-    # given block to an array of the corresponding elements of +self+ and
-    # the input lists.
-    # +xs.zip_with(*yss, &block)+ is equivalent to
-    # +xs.zip(*yss).map(&block)+.
-    #
-    # @param [Array<List>] xss the input lists.
-    # @return [List] the new list.
-    def zip_with(*xss, &block)
-      # this method should be overriden
+    def class_name
+      "List"
     end
   end
 
@@ -421,205 +157,5 @@ module Immutable
     def empty?
       false
     end
-
-    def Nil.foldr(e)
-      e
-    end
-
-    def foldr(e, &block)
-      yield(@head, @tail.foldr(e, &block))
-    end
-
-    def Nil.foldr1
-      raise EmptyError
-    end
-
-    def foldr1(&block)
-      if @tail.empty?
-        @head
-      else
-        yield(@head, @tail.foldr1(&block))
-      end
-    end
-
-    def Nil.each
-    end
-
-    def each(&block)
-      yield(@head)
-      @tail.each(&block)
-    end
-
-    def Nil.foldl(e)
-      e
-    end
-
-    def foldl(e, &block)
-      @tail.foldl(yield(e, @head), &block)
-    end
-
-    def Nil.foldl1
-      raise EmptyError
-    end
-
-    def foldl1(&block)
-      @tail.foldl(@head, &block)
-    end
-
-    def Nil.==(xs)
-      equal?(xs)
-    end
-
-    def ==(xs)
-      if !xs.is_a?(List) || xs.empty?
-        false
-      else
-        @head == xs.head && @tail == xs.tail
-      end
-    end
-
-    def Nil.inspect
-      "List[]"
-    end
-
-    def inspect
-      "List[" + @head.inspect +
-        @tail.foldl("") {|x, y| x + ", " + y.inspect } + "]"
-    end
-
-    def Nil.intersperse(sep)
-      Nil
-    end
-
-    def intersperse(sep)
-      Cons[@head, @tail.prepend_to_all(sep)]
-    end
-
-    def Nil.prepend_to_all(sep)
-      Nil
-    end
-
-    def prepend_to_all(sep)
-      Cons[sep, Cons[@head, @tail.prepend_to_all(sep)]]
-    end
-
-    def Nil.transpose
-      Nil
-    end
-
-    def transpose
-      if @head == Nil
-        @tail.transpose
-      else
-        tail = @tail.filter { |x| !x.empty? }
-        Cons[Cons[@head.head, tail.map(&:head)],
-          Cons[@head.tail, tail.map(&:tail)].transpose]
-      end
-    end
-
-    def Nil.nonempty_subsequences
-      List[]
-    end
-
-    def nonempty_subsequences
-      yss = @tail.nonempty_subsequences.foldr(List[]) { |xs, xss|
-        Cons[xs, Cons[Cons[@head, xs], xss]]
-      }
-      Cons[List[@head], yss]
-    end
-
-    def Nil.[](n)
-      nil
-    end
-
-    def [](n)
-      if n < 0
-        nil
-      elsif n == 0
-        head
-      else
-        tail[n - 1]
-      end
-    end
-
-    def Nil.take(n)
-      Nil
-    end
-
-    def take(n)
-      if n <= 0
-        Nil
-      else
-        Cons[@head, @tail.take(n - 1)]
-      end
-    end
-
-    def Nil.take_while
-      Nil
-    end
-
-    def take_while(&block)
-      if yield(@head)
-        Cons[@head, @tail.take_while(&block)]
-      else
-        Nil
-      end
-    end
-
-    def Nil.drop(n)
-      Nil
-    end
-
-    def drop(n)
-      if n > 0
-        @tail.drop(n - 1)
-      else
-        self
-      end
-    end
-
-    def Nil.drop_while
-      Nil
-    end
-
-    def drop_while(&block)
-      if yield(@head)
-        @tail.drop_while(&block)
-      else
-        self
-      end
-    end
-
-    def Nil.find
-      nil
-    end
-
-    def find(&block)
-      if yield(@head)
-        @head
-      else
-        @tail.find(&block)
-      end
-    end
-
-    def Nil.zip(*xss)
-      Nil
-    end
-
-    def zip(*xss)
-      heads = xss.map { |xs| xs.null? ? nil : xs.head }
-      tails = xss.map { |xs| xs.null? ? Nil : xs.tail }
-      Cons[[head, *heads], tail.zip(*tails)]
-    end
-
-    def Nil.zip_with(*xss, &block)
-      Nil
-    end
-
-    def zip_with(*xss, &block)
-      heads = xss.map { |xs| xs.null? ? nil : xs.head }
-      tails = xss.map { |xs| xs.null? ? Nil : xs.tail }
-      Cons[yield(head, *heads), tail.zip_with(*tails, &block)]
-    end
   end
 end