rubymotionlisp 0.1.4 → 0.2.0

data/lib/rubylisp/list_support.rb

@@ -59,7 +59,7 @@ module Lisp
 
 
     def self.cons_impl(args, env)
-      raise "cons requires two arguments." unless args.length == 2
+      return Lisp::Debug.process_error("cons requires two arguments.", env) unless args.length == 2
       left = args.car.evaluate(env)
       right = args.cadr.evaluate(env)
       Lisp::ConsCell.cons(left, right)
@@ -85,9 +85,9 @@ module Lisp
 
 
     def self.make_list_impl(args, env)
-      raise "consmake-list requires one or two arguments." unless args.length == 1 || args.length == 2
+      return Lisp::Debug.process_error("consmake-list requires one or two arguments.", env) unless args.length == 1 || args.length == 2
       arg1 = args.car.evaluate(env)
-      raise "make-list requires an integer for it's first argument, received: #{args.car}" unless arg1.integer?
+      return Lisp::Debug.process_error("make-list requires an integer for it's first argument, received: #{args.car}", env) unless arg1.integer?
       count = arg1.value
       val = if args.length == 1
               nil
@@ -101,16 +101,16 @@ module Lisp
 
 
     def self.iota_impl(args, env)
-      raise "iota requires at least one argument." unless args.length > 0
+      return Lisp::Debug.process_error("iota requires at least one argument.", env) unless args.length > 0
       arg1 = args.car.evaluate(env)
-      raise "iota requires an positive integer for it's first argument, received: #{args.car}" unless arg1.integer? && arg1.positive?
+      return Lisp::Debug.process_error("iota requires an positive integer for it's first argument, received: #{args.car}", env) unless arg1.integer? && arg1.positive?
       count = arg1.value
 
       start = if args.length < 2
                 0
               else
                 arg2 = args.cadr.evaluate(env)
-                raise "iota requires an number for it's second argument, received: #{args.cadr}" unless arg2.number?
+                return Lisp::Debug.process_error("iota requires an number for it's second argument, received: #{args.cadr}", env) unless arg2.number?
                 arg2.value
               end
 
@@ -118,7 +118,7 @@ module Lisp
                 1
               else
                 arg3 = args.caddr.evaluate(env)
-                raise "iota requires an number for it's third argument, received: #{args.caddr}" unless arg3.number?
+                return Lisp::Debug.process_error("iota requires an number for it's third argument, received: #{args.caddr}", env) unless arg3.number?
                 arg3.value
               end
 
@@ -140,22 +140,22 @@ module Lisp
     # in support of all the CxR functions
     def self.ad_impl(args, env, f)
       l = args.car.evaluate(env)
-      raise "list required." unless l.list?
+      return Lisp::Debug.process_error("list required.", env) unless l.list?
       l.send(f)
     end
 
 
     def self.first_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 1
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 1
       l.nth(1)
     end
 
 
     def self.rest_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
       if l.list?
         l.cdr
       else
@@ -166,82 +166,82 @@ module Lisp
 
     def self.second_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 2
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 2
       l.nth(2)
     end
 
     def self.third_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 3
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 3
       l.nth(3)
     end
 
 
     def self.fourth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 4
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 4
       l.nth(4)
     end
 
 
     def self.fifth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 5
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 5
       l.nth(5)
     end
 
 
     def self.sixth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 6
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 6
       l.nth(6)
     end
 
 
     def self.seventh_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 7
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 7
       l.nth(7)
     end
 
 
     def self.eighth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 8
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 8
       l.nth(8)
     end
 
 
     def self.ninth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 9
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 9
       l.nth(9)
     end
 
 
     def self.tenth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 10
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 10
       l.nth(10)
     end
 
 
     def self.nth_impl(args, env)
-      raise "nth requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("nth requires 2 arguments", env) unless args.length == 2
       n = args.car.evaluate(env)
-      raise "The first argument of nth has to be an number." unless n.number?
-      raise "The first argument of nth has to be positive." unless n.value > 0
+      return Lisp::Debug.process_error("The first argument of nth has to be an number.", env) unless n.number?
+      return Lisp::Debug.process_error("The first argument of nth has to be positive.", env) unless n.value > 0
       l = args.cadr.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
       l.nth(n.value)
     end
 
@@ -256,78 +256,77 @@ module Lisp
     
 
     def self.sublist_impl(args, env)
-      raise "sublist requires 3 arguments" unless args.length == 3
+      return Lisp::Debug.process_error("sublist requires 3 arguments", env) unless args.length == 3
       l = args.car.evaluate(env)
-      raise "sublist requires it's first argument to be a list or vector, but received #{args.car}" unless l.list? || l.vector?
+      return Lisp::Debug.process_error("sublist requires it's first argument to be a list or vector, but received #{args.car}", env) unless l.list? || l.vector?
       st = args.cadr.evaluate(env)
-      raise "sublist requires it's second argument to be a positive integer, but received #{args.cadr}" unless st.number? && st.positive?
-      raise "sublist requires it's second argument to be <= the list length" unless st.value <= l.length
+      return Lisp::Debug.process_error("sublist requires it's second argument to be a positive integer, but received #{args.cadr}", env) unless st.number? && st.positive?
+      return Lisp::Debug.process_error("sublist requires it's second argument to be <= the list length", env) unless st.value <= l.length
       en = args.caddr.evaluate(env)
-      raise "sublist requires it's third argument to be a positive integer, but received #{args.caddr}" unless en.number? && en.positive?
-      raise "sublist requires it's third argument to be <= the list length" unless en.value <= l.length
-      raise "sublist requires it's second argument to be <= the third argument" unless st.value <= en.value
+      return Lisp::Debug.process_error("sublist requires it's third argument to be a positive integer, but received #{args.caddr}", env) unless en.number? && en.positive?
+      return Lisp::Debug.process_error("sublist requires it's third argument to be <= the list length", env) unless en.value <= l.length
+      return Lisp::Debug.process_error("sublist requires it's second argument to be <= the third argument", env) unless st.value <= en.value
       make_same_kind_as(l, l.to_a[(st.value - 1)...en.value])
     end
 
 
     def self.list_head_impl(args, env)
-      raise "list_head requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("list_head requires 2 arguments", env) unless args.length == 2
       l = args.car.evaluate(env)
-      raise "list_head requires it's first argument to be a list, but received #{args.car}" unless l.list?
+      return Lisp::Debug.process_error("list_head requires it's first argument to be a list, but received #{args.car}", env) unless l.list?
       k = args.cadr.evaluate(env)
-      raise "list_head requires it's second argument to be a positive integer, but received #{args.cadr}" unless k.number? && k.positive?
-      raise "list_head requires it's second argument to be <= the list length" unless k.value <= l.length
+      return Lisp::Debug.process_error("list_head requires it's second argument to be a positive integer, but received #{args.cadr}", env) unless k.number? && k.positive?
+      return Lisp::Debug.process_error("list_head requires it's second argument to be <= the list length", env) unless k.value <= l.length
       Lisp::ConsCell.array_to_list(l.to_a[0...k.value])
     end
 
 
     def self.take_impl(args, env)
-      raise "take requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("take requires 2 arguments", env) unless args.length == 2
       k = args.car.evaluate(env)
-      raise "take requires it's first argument to be an integer >= 0, but received #{args.car}" unless k.number? && !k.negative?
+      return Lisp::Debug.process_error("take requires it's first argument to be an integer >= 0, but received #{args.car}", env) unless k.number? && !k.negative?
       l = args.cadr.evaluate(env)
-      raise "take requires it's second argument to be a list or vector, but received #{args.cadr}" unless l.list? || l.vector?
-      raise "take requires it's first argument to be <= the list length" unless k.value <= l.length
-      puts l
+      return Lisp::Debug.process_error("take requires it's second argument to be a list or vector, but received #{args.cadr}", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("take requires it's first argument to be <= the list length", env) unless k.value <= l.length
       make_same_kind_as(l, l.to_a[0...k.value])
     end
 
 
     def self.list_tail_impl(args, env)
-      raise "list_head requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("list_head requires 2 arguments", env) unless args.length == 2
       l = args.car.evaluate(env)
-      raise "list_head requires it's first argument to be a list, but received #{args.car}" unless l.list?
+      return Lisp::Debug.process_error("list_head requires it's first argument to be a list, but received #{args.car}", env) unless l.list?
       k = args.cadr.evaluate(env)
-      raise "list_head requires it's second argument to be a positive integer, but received #{args.cadr}" unless k.number? && k.positive?
-      raise "list_head requires it's second argument to be <= the list length" unless k.value <= l.length
+      return Lisp::Debug.process_error("list_head requires it's second argument to be a positive integer, but received #{args.cadr}", env) unless k.number? && k.positive?
+      return Lisp::Debug.process_error("list_head requires it's second argument to be <= the list length", env) unless k.value <= l.length
       l.nth_tail(k.value + 1)
     end
 
 
     def self.drop_impl(args, env)
-      raise "drop requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("drop requires 2 arguments", env) unless args.length == 2
       k = args.car.evaluate(env)
-      raise "drop requires it's first argument to be an integer >= 0, but received #{args.car}" unless k.number? && !k.negative?
+      return Lisp::Debug.process_error("drop requires it's first argument to be an integer >= 0, but received #{args.car}", env) unless k.number? && !k.negative?
       l = args.cadr.evaluate(env)
-      raise "drop requires it's second argument to be a list or vector, but received #{args.cadr}" unless l.list? || l.vector?
-      raise "drop requires it's first argument to be <= the list length" unless k.value <= l.length
+      return Lisp::Debug.process_error("drop requires it's second argument to be a list or vector, but received #{args.cadr}", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("drop requires it's first argument to be <= the list length", env) unless k.value <= l.length
       l.nth_tail(k.value + 1)
     end
 
 
     def self.last_pair_impl(args, env)
-      raise "last_pair requires 1 arguments" unless args.length == 1
+      return Lisp::Debug.process_error("last_pair requires 1 arguments", env) unless args.length == 1
       l = args.car.evaluate(env)
-      raise "last_pair requires it's argument to be a list, but received #{args.car}" unless l.list?
+      return Lisp::Debug.process_error("last_pair requires it's argument to be a list, but received #{args.car}", env) unless l.list?
       l.last
     end
 
 
     def self.memq_impl(args, env)
-      raise "memq requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("memq requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       item = args.car.evaluate(env)
       collection = args.cadr.evaluate(env)
-      raise "memq requires a list as it's second argument." unless collection.list?
+      return Lisp::Debug.process_error("memq requires a list as it's second argument.", env) unless collection.list?
       collection.length.times do |i|
         if Lisp::Equivalence.eq_check(item, collection.nth(i + 1)).value
           return collection.nth_tail(i + 1)
@@ -338,10 +337,10 @@ module Lisp
 
 
     def self.memv_impl(args, env)
-      raise "memv requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("memv requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       item = args.car.evaluate(env)
       collection = args.cadr.evaluate(env)
-      raise "memv requires a list as it's second argument." unless collection.list?
+      return Lisp::Debug.process_error("memv requires a list as it's second argument.", env) unless collection.list?
       collection.length.times do |i|
         if Lisp::Equivalence.eqv_check(item, collection.nth(i + 1)).value
           return collection.nth_tail(i + 1)
@@ -352,10 +351,10 @@ module Lisp
 
 
     def self.member_impl(args, env)
-      raise "member requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("member requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       item = args.car.evaluate(env)
       collection = args.cadr.evaluate(env)
-      raise "member requires a list as it's second argument." unless collection.list?
+      return Lisp::Debug.process_error("member requires a list as it's second argument.", env) unless collection.list?
       collection.length.times do |i|
         if Lisp::Equivalence.equal_check(item, collection.nth(i + 1)).value
           return collection.nth_tail(i + 1)
@@ -366,33 +365,33 @@ module Lisp
 
 
     def self.filter_impl(args, env)
-      raise "filter requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("filter requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       f = args.car.evaluate(env)
-      raise "filter requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("filter requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       collection = args.cadr.evaluate(env)
-      raise "filter requires a list or vector as it's second argument but received #{args.cadr}." unless collection.list? || collection.vector?
+      return Lisp::Debug.process_error("filter requires a list or vector as it's second argument but received #{args.cadr}.", env) unless collection.list? || collection.vector?
       results = collection.to_a.select {|item| f.apply_to_without_evaluating(Lisp::ConsCell.cons(item, nil), env).value }
       make_same_kind_as(collection, results)
     end
 
 
     def self.remove_impl(args, env)
-      raise "remove requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("remove requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       f = args.car.evaluate(env)
-      raise "remove requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("remove requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       collection = args.cadr.evaluate(env)
-      raise "remove requires a list or vector as it's second argument but received #{args.cadr}." unless collection.list? || collection.vector?
+      return Lisp::Debug.process_error("remove requires a list or vector as it's second argument but received #{args.cadr}.", env) unless collection.list? || collection.vector?
       results = collection.to_a.reject {|item| f.apply_to_without_evaluating(Lisp::ConsCell.cons(item, nil), env).value }
       make_same_kind_as(collection, results)
     end
 
 
     def self.partition_impl(args, env)
-      raise "partition requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("partition requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       f = args.car.evaluate(env)
-      raise "partition requires a function as it's first argument." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("partition requires a function as it's first argument.", env) unless f.function? || f.primitive?
       collection = args.cadr.evaluate(env)
-      raise "partition requires a list as it's second argument." unless collection.list? | collection.vector?
+      return Lisp::Debug.process_error("partition requires a list as it's second argument.", env) unless collection.list? | collection.vector?
       results = collection.to_a.partition {|item| f.apply_to_without_evaluating(Lisp::ConsCell.cons(item, nil), env).value }
       matches = make_same_kind_as(collection, results[0])
       non_matches = make_same_kind_as(collection, results[1])
@@ -401,11 +400,11 @@ module Lisp
 
 
     def self.map_impl(args, env)
-      raise "map requires at least 2 arguments but received #{args.length}." if args.length < 2
+      return Lisp::Debug.process_error("map requires at least 2 arguments but received #{args.length}.", env) if args.length < 2
       f = args.car.evaluate(env)
-      raise "map requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("map requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       collections = args.cdr.to_a.collect {|a| a.evaluate(env)}
-      raise "all requires all subsequent arguments to be lists or vectors" unless collections.all? {|l| l.list? || l.vector?}
+      return Lisp::Debug.process_error("all requires all subsequent arguments to be lists or vectors", env) unless collections.all? {|l| l.list? || l.vector?}
       all_vectors = collections.all? {|i| i.vector?}
       lists = collections.collect {|l| l.to_a }
       
@@ -430,12 +429,12 @@ module Lisp
 
 
     def self.reduce_left_impl(args, env)
-      raise "reduce requires 3 arguments but received #{args.length}." unless args.length == 3
+      return Lisp::Debug.process_error("reduce requires 3 arguments but received #{args.length}.", env) unless args.length == 3
       f = args.car.evaluate(env)
-      raise "map requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("map requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       initial = args.cadr.evaluate(env)
       collection = args.caddr.evaluate(env)
-      raise "reduce requires a list or vector as it's third argument but received #{args.caddr}." unless collection.list? || collection.vector?
+      return Lisp::Debug.process_error("reduce requires a list or vector as it's third argument but received #{args.caddr}.", env) unless collection.list? || collection.vector?
       return initial if collection.empty?
       return collection.nth(1) if collection.length == 1
       result = collection.to_a.inject do |acc, item|
@@ -446,11 +445,11 @@ module Lisp
 
 
     def self.any_impl(args, env)
-      raise "any requires at least two arguments" unless args.length >= 2
+      return Lisp::Debug.process_error("any requires at least two arguments", env) unless args.length >= 2
       p = args.car.evaluate(env)
-      raise "any requires a function as it's first argument" unless p.function? || p.primitive?
+      return Lisp::Debug.process_error("any requires a function as it's first argument", env) unless p.function? || p.primitive?
       lists = args.cdr.to_a.collect {|a| a.evaluate(env)}
-      raise "any requires all subsequent arguments to be lists or vectors" unless lists.all? {|l| l.list? || l.vector?}
+      return Lisp::Debug.process_error("any requires all subsequent arguments to be lists or vectors", env) unless lists.all? {|l| l.list? || l.vector?}
 
       while true
         cars = lists.collect {|l| l.nth(1)}
@@ -463,11 +462,11 @@ module Lisp
 
 
     def self.every_impl(args, env)
-      raise "all requires at least two arguments" unless args.length >= 2
+      return Lisp::Debug.process_error("all requires at least two arguments", env) unless args.length >= 2
       p = args.car.evaluate(env)
-      raise "all requires a function as it's first argument" unless p.function? || p.primitive?
+      return Lisp::Debug.process_error("all requires a function as it's first argument", env) unless p.function? || p.primitive?
       lists = args.cdr.to_a.collect {|a| a.evaluate(env)}
-      raise "all requires all subsequent arguments to be lists or vectors" unless lists.all? {|l| l.list? || l.vector?}
+      return Lisp::Debug.process_error("all requires all subsequent arguments to be lists or vectors", env) unless lists.all? {|l| l.list? || l.vector?}
 
       while true
         cars = lists.collect {|l| l.nth(1)}
@@ -480,17 +479,17 @@ module Lisp
 
 
     def self.reverse_impl(args, env)
-      raise "reverse requires a single argument." unless args.length == 1
+      return Lisp::Debug.process_error("reverse requires a single argument.", env) unless args.length == 1
       l = args.car.evaluate(env)
-      raise "reverse requires a list or vector" unless l.list? || l.vector?
+      return Lisp::Debug.process_error("reverse requires a list or vector", env) unless l.list? || l.vector?
       make_same_kind_as(l, l.to_a.reverse)
     end
 
 
     def self.append_impl(args, env)
-      raise "append requires at least 1 argument." unless args.length >= 1
+      return Lisp::Debug.process_error("append requires at least 1 argument.", env) unless args.length >= 1
       l = args.map {|i| i.evaluate(env)}
-      raise "append requires lists or vectors" unless l.all? {|i| i.list? || i.vector?}
+      return Lisp::Debug.process_error("append requires lists or vectors", env) unless l.all? {|i| i.list? || i.vector?}
       all_vectors = l.all? {|i| i.vector?}
       new_items = []
       l.each do |sublist|
@@ -506,9 +505,9 @@ module Lisp
 
 
     def self.appendbang_impl(args, env)
-      raise "append! requires at least 1 argument." unless args.length >= 1
+      return Lisp::Debug.process_error("append! requires at least 1 argument.", env) unless args.length >= 1
       arg_array = args.to_a.map {|i| i.evaluate(env)}
-      raise "append! requires lists" unless arg_array.all? {|i| i.list?}
+      return Lisp::Debug.process_error("append! requires lists", env) unless arg_array.all? {|i| i.list?}
       (0...(arg_array.length-1)). each do |i|
         arg_array[i].last.set_cdr!(arg_array[i+1])
       end
@@ -517,9 +516,9 @@ module Lisp
 
 
     def self.flatten_impl(args, env)
-      raise "flatten requires 1 argument." unless args.length != 1
+      return Lisp::Debug.process_error("flatten requires 1 argument.", env) unless args.length != 1
       l = args.car.evaluate(env)
-      raise "flatten requires a list argument" unless l.list?
+      return Lisp::Debug.process_error("flatten requires a list argument", env) unless l.list?
       l.flatten
     end