lib/nydp/pair.rb in nydp-0.2.3 vs lib/nydp/pair.rb in nydp-0.2.5

@@ -6,25 +6,36 @@
 
   def initialize car, cdr
     @car, @cdr = car, cdr
   end
 
-  def nydp_type  ; :pair                            ; end
-  def caar       ; car.car                          ; end
-  def cadr       ; cdr.car                          ; end
-  def cdar       ; car.cdr                          ; end
-  def cddr       ; cdr.cdr                          ; end
-  def car= thing ; @car = thing ; @_hash = nil      ; end
-  def cdr= thing ; @cdr = thing ; @_hash = nil      ; end
-  def hash       ; @_hash ||= (car.hash + cdr.hash) ; end
-  def eql? other ; self == other                    ; end
+  def nydp_type  ; :pair                                      ; end
+  def caar       ; car.car                                    ; end
+  def cadr       ; cdr.car                                    ; end
+  def cdar       ; car.cdr                                    ; end
+  def cddr       ; cdr.cdr                                    ; end
+  def car= thing ; @car = thing ; @_hash = nil                ; end
+  def cdr= thing ; @cdr = thing ; @_hash = nil                ; end
+  def hash       ; @_hash ||= (car.hash + cdr.hash)           ; end
+  def eql? other ; self == other                              ; end
+  def copy       ; cons(car, cdr.copy)                        ; end
+  def +    other ; copy.append other                          ; end
+  def size       ; 1 + (cdr.is_a?(Nydp::Pair) ? cdr.size : 0) ; end
+  def inspect    ; "(#{inspect_rest})"                        ; end
 
+  # returns Array of elements after calling #n2r on each element
   def to_ruby list=[]
     list << n2r(car)
     cdr.is_a?(Nydp::Pair) ? cdr.to_ruby(list) : list
   end
 
+  # returns Array of elements as they are
+  def to_a list=[]
+    list << car
+    cdr.is_a?(Nydp::Pair) ? cdr.to_a(list) : list
+  end
+
   def self.parse_list list
     if sym? list.slice(-2), "."
       from_list(list[0...-2], list.slice(-1))
     else
       from_list list
@@ -37,39 +48,23 @@
     else
       new list[n], from_list(list, last, n+1)
     end
   end
 
-  def copy
-    cons(car, cdr.copy)
-  end
-
-  def + other
-    copy.append other
-  end
-
   def == other
-    (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
+    Nydp::NIL.isnt?(other) && (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
   end
 
-  def size
-    1 + (cdr.is_a?(Nydp::Pair) ? cdr.size : 0)
-  end
-
   def proper?
     Nydp::NIL.is?(cdr) || (cdr.is_a?(Nydp::Pair) && cdr.proper?)
   end
 
   def each &block
     yield car
     cdr.each(&block) unless Nydp::NIL.is?(cdr)
   end
 
-  def inspect
-    "(#{inspect_rest})"
-  end
-
   def to_s
     if car.is_a?(Nydp::Symbol) && car.is?(:quote)
       if Nydp::NIL.is? cdr.cdr
         "'#{cdr.car.to_s}"
       else
@@ -115,18 +110,22 @@
 
     [car.to_s, cdr_s].compact.join " "
   end
 
   def inspect_rest
-    cdr_s = if cdr.is_a?(self.class)
-              cdr.inspect_rest
-            elsif cdr == Nydp::NIL
-              nil
-            else
-              ". #{cdr.inspect}"
-            end
-
-    [car.inspect, cdr_s].compact.join " "
+    res = [car.inspect]
+    it = cdr
+    while it && it != Nydp::NIL
+      if it.is_a?(self.class)
+        res << it.car.inspect
+        it = it.cdr
+      else
+        res << "."
+        res << it.inspect
+        it = nil
+      end
+    end
+    res.compact.join " "
   end
 
   def append thing
     if Nydp::NIL.is? self.cdr
       self.cdr = thing