nydp 0.2.3 → 0.2.5

data/lib/lisp/tests/none-examples.nydp

@@ -0,0 +1,16 @@
+(examples-for none?
+  ("nil when any items match"
+   (none? num? '(1 nil nil 4))
+   nil)
+
+  ("nil for a non-nil atom"
+   (and (none? string? "really, all") t)
+   nil)
+
+  ("t for nil"
+   (none? x1 nil)
+   t)
+
+  ("t when all items are nil"
+   (and (none? x1 '(nil nil nil nil)) t)
+   t))

data/lib/lisp/tests/parser-tests.nydp

@@ -36,10 +36,9 @@
    (parse "$this.that.zozo")
    ((dot-syntax (dollar-syntax || this) that zozo)))
 
-
-  ("parses an expression"
+  ("parses a list of expressions"
    (parse "(foo bar \"hello, String\") 1 2 (3 t nil) nil")
-   ((foo bar "hello, String") 1 2 (3 t nil))))
+   ((foo bar "hello, String") 1 2 (3 t nil) nil)))
 
 (examples-for parse-in-string
   ("parses a plain string"
@@ -67,5 +66,5 @@
    13)
 
   ("reports parse errors gracefully"
-   (on-err "CAUGHT: ~err" (parse-in-string (joinstr "" "blah ~~(\"stri...")))
-   "CAUGHT: parse error: \"unterminated string\" in\n  blah ~~(\"stri..." ))
+   (on-err "CAUGHT: ~(joinstr "\n" errors)" (parse-in-string (joinstr "" "blah ~~(\"stri...")))
+   "CAUGHT: parse error: \"unterminated string\" in\n  blah ~~(\"stri...\nunterminated string" ))

data/lib/lisp/tests/quasiquote-examples.nydp

@@ -4,7 +4,9 @@
   ("substitutes single variables"                  (let b 10 `(a ,b c))                                   (a 10 c))
   ("substitutes a list"                            (let b '(1 2 3) `(a ,@b c))                            (a 1 2 3 c))
   ("substitutes a list at the end of a given list" (let b '(1 2 3) `(a ,b ,@b))                           (a (1 2 3) 1 2 3))
+  ("unquotes an improper tail"                     (let c 42 `(a b . ,c))                                 (a b . 42))
   ("more complicated substitution example"         (with (d '(1 2 3) g '(x y z)) `(a (b c ,d (e f ,@g)))) (a (b c (1 2 3) (e f x y z))))
   ("peeks inside nested quotes"                    `(a b '(c ,(+ 1 2)))                                   (a b '(c 3)))
   ("handles nested unquote-splicing"               ``(a ,,@(list '+ 1 2) b)                               `((a ,(+ 1 2) b)))
+  ("unquote-splices an improper tail"              (let c '(1 2 3) `(a b . ,@c))                          (a b 1 2 3))
   ("returns nested quasiquotes"                    `(a b `(c d ,(+ 1 2) ,,(+ 3 4)))                       (a b `(c d ,(+ 1 2) ,7))))

data/lib/lisp/tests/syntax-tests.nydp

@@ -8,8 +8,9 @@
    b)
 
   ("dislikes no-prefix"
-   (on-err err (pre-compile '(:foo 1 2 3)))
-   "(\"Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo\")"))
+   (on-err (joinstr "\n" errors)
+           (pre-compile '(:foo 1 2 3)))
+   "\"Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo\""))
 
 (examples-for prefix-list
   ("one argument"

data/lib/lisp/tests/tuples-examples.nydp

@@ -5,7 +5,7 @@
 
   ("returns single list for fewer than n items"
    (tuples 4 '(a b) )
-   ((a b nil nil)))
+   ((a b)))
 
   ("returns exactly one list for exactly n items"
    (tuples 5 '(a b c d e) )
@@ -13,4 +13,4 @@
 
   ("returns the given list split into sublist each having n items"
    (tuples 3 '(a b c d e f g) )
-   ((a b c) (d e f) (g nil nil))))
+   ((a b c) (d e f) (g))))

data/lib/nydp.rb

@@ -4,6 +4,7 @@ require 'set'
 module Nydp
   class Namespace < Hash
   end
+
   def self.apply_function ns, function_name, *args
     function = r2n(function_name.to_sym, ns).value
     args     = r2n args, ns
@@ -15,32 +16,63 @@ module Nydp
 
   def self.reader                          txt ; Nydp::StringReader.new txt                                 ; end
   def self.eval_src      ns, src_txt, name=nil ; eval_with Nydp::Runner, ns, src_txt, name                  ; end
-  def self.eval_src!     ns, src_txt, name=nil ; eval_with Nydp::ExplodeRunner, ns, src_txt, name           ; end
   def self.eval_with runner, ns, src_txt, name ; runner.new(VM.new(ns), ns, reader(src_txt), nil, name).run ; end
   def self.ms                           t1, t0 ; ((t1 - t0) * 1000).to_i                                    ; end
 
+  def self.indent_message indent, msg
+    msg.split(/\n/).map { |line| "#{indent}#{line}" }.join("\n")
+  end
+
+  def self.handle_run_error e, indent=""
+    puts "#{indent}#{e.class.name}"
+    puts "#{indent_message indent, e.message}"
+    if e.cause
+      puts "#{indent}#{e.backtrace.first}"
+      puts "\n#{indent}Caused by:"
+      handle_run_error e.cause, "#{indent}    "
+    else
+      e.backtrace.each do |b|
+        puts "#{indent}#{b}"
+      end
+    end
+  end
+
+  def self.toplevel
+    begin
+      yield
+    rescue StandardError => e
+      handle_run_error e
+    end
+  end
+
   def self.repl options={ }
-    launch_time = Time.now
-    last_script_time = Time.now
-    puts "welcome to nydp"
-    reader = Nydp::ReadlineReader.new $stdin, "nydp > "
-    ns     = build_nydp do |script|
-      this_script_time = Time.now
-      puts "script #{script} time #{ms this_script_time, last_script_time}ms" if options[:verbose]
-      last_script_time = this_script_time
+    toplevel do
+      silent = options[:silent]
+      launch_time = Time.now
+      last_script_time = Time.now
+      puts "welcome to nydp #{options.inspect}" unless silent
+      reader = Nydp::ReadlineReader.new $stdin, "nydp > "
+      ns     = build_nydp do |script|
+        this_script_time = Time.now
+        puts "script #{script} time #{ms this_script_time, last_script_time}ms" if options[:verbose]
+        last_script_time = this_script_time
+      end
+      load_time = Time.now
+      puts "nydp v#{Nydp::VERSION} repl ready in #{ms(load_time, launch_time)}ms" unless silent
+      puts "^D to exit" unless silent
+      return if options[:exit]
+      Nydp::Runner.new(VM.new(ns), ns, reader, $stdout, "<stdin>").run
     end
-    load_time = Time.now
-    puts "repl ready in #{ms(load_time, launch_time)}ms"
-    puts "^D to exit"
-    Nydp::Runner.new(VM.new(ns), ns, reader, $stdout, "<stdin>").run
   end
 
   def self.tests *options
-    verbose = options.include?(:verbose) ? "t" : "nil"
-    puts "welcome to nydp : running tests"
-    reader = Nydp::StringReader.new "(run-all-tests #{verbose})"
-    ns     = build_nydp
-    Nydp::Runner.new(VM.new(ns), ns, reader, nil, "<test-runner>").run
+    toplevel do
+      verbose = options.include?(:verbose) ? "t" : "nil"
+      puts "welcome to nydp : running tests"
+      reader = Nydp::StringReader.new "(run-all-tests #{verbose})"
+      ns     = build_nydp
+      Nydp::Runner.new(VM.new(ns), ns, reader, nil, "<test-runner>").run
+    end
   end
 end
 

data/lib/nydp/assignment.rb

@@ -1,5 +1,7 @@
 module Nydp
   class AssignmentInstruction
+    attr_accessor :name
+
     def initialize name
       @name = name
     end
@@ -30,7 +32,7 @@ module Nydp
     end
 
     def to_s
-      "#assignment #{@instructions.cdr.car} #{@value_src.inspect}"
+      "(assign #{@instructions.cdr.car.name} #{@value_src.inspect})"
     end
 
     def inspect; to_s ; end

data/lib/nydp/builtin.rb

@@ -10,41 +10,43 @@ module Nydp::Builtin
 
     def invoke_1 vm
       builtin_invoke_1 vm
-    rescue Exception => e
-      handle_error e, Nydp::NIL
+    rescue StandardError => e
+      handle_error e
     end
 
     def invoke_2 vm, arg
       builtin_invoke_2 vm, arg
-    rescue Exception => e
-      handle_error e, cons(arg)
+    rescue StandardError => e
+      handle_error e, arg
     end
 
     def invoke_3 vm, arg_0, arg_1
       builtin_invoke_3 vm, arg_0, arg_1
-    rescue Exception => e
-      handle_error e, cons(arg_0, cons(arg_1))
+    rescue StandardError => e
+      handle_error e, arg_0, arg_1
     end
 
     def invoke_4 vm, arg_0, arg_1, arg_2
       builtin_invoke_4 vm, arg_0, arg_1, arg_2
-    rescue Exception => e
-      handle_error e, cons(arg_0, cons(arg_1, cons(arg_2)))
+    rescue StandardError => e
+      handle_error e, arg_0, arg_1, arg_2
     end
 
     def invoke vm, args
       builtin_invoke vm, args
-    rescue Exception => e
-      handle_error e, args
+    rescue StandardError => e
+      handle_error e, *(args.to_a)
     end
 
-    def handle_error e, args
+
+    def handle_error e, *args
       case e
       when Nydp::Error
         raise e
       else
-        new_msg = "Called #{self.inspect}\nwith args #{args.inspect}\nraised\n#{Nydp.indent_text e.message}\nat #{e.backtrace.first}"
-        raise $!, new_msg, $!.backtrace
+        arg_msg = args.map { |a| "  #{a.inspect}"}.join("\n")
+        new_msg = "Called #{self.inspect}\nwith args\n#{arg_msg}"
+        raise new_msg
       end
     end
 

data/lib/nydp/builtin/error.rb

@@ -4,6 +4,6 @@ class Nydp::Builtin::Error
   # override #invoke on nydp/builtin/base because
   # we don't want to inherit error handling
   def builtin_invoke vm, args
-    raise Nydp::Error.new(args.inspect)
+    raise Nydp::Error.new(args.to_a.map(&:inspect).join("\n"), vm.last_error)
   end
 end

data/lib/nydp/builtin/handle_error.rb

@@ -13,13 +13,19 @@ class Nydp::Builtin::HandleError
     end
 
     def execute vm
-      e = vm.unhandled_error
+      e = vm.last_error = vm.unhandled_error
       vm.unhandled_error = nil
       return unless e
 
       vm.args = vm.args[0...vm_arg_array_size]
 
-      handler.invoke vm, cons(r2n e.message, nil)
+      msgs = []
+      while e
+        msgs << e.message
+        e = e.cause
+      end
+
+      handler.invoke_2 vm, vm.r2n(msgs)
     end
 
     def to_s

data/lib/nydp/builtin/parse_in_string.rb

@@ -7,7 +7,7 @@ class Nydp::Builtin::ParseInString
     tokens = Nydp::Tokeniser.new Nydp::StringReader.new parsable
     expr = parser.string(tokens, "", :eof)
     vm.push_arg expr
-  rescue Exception => e
+  rescue StandardError => e
     new_msg = "parse error: #{e.message.inspect} in\n#{Nydp.indent_text parsable}"
     raise Nydp::Error.new new_msg
   end

data/lib/nydp/builtin/plus.rb

@@ -18,11 +18,11 @@ class Nydp::Builtin::Plus
   end
 
   def sum args, accum
-    if Nydp::NIL.is? args
-      accum
-    else
-      sum(args.cdr, (accum + args.car))
+    while args && !Nydp::NIL.is?(args)
+      accum += args.car
+      args = args.cdr
     end
+    accum
   end
 
   def name ; "+" ; end

data/lib/nydp/closure.rb

@@ -4,6 +4,9 @@ module Nydp
 
     def initialize ifn, context
       @ifn, @context = ifn, context
+      # TODO don't create a closure where it's not needed (zero_arg functions), use parent context instead
+      # TODO see SymbolLookup for how to ensure variable references stay on track
+      # TODO see InterpretedFunction for where to not instantiate new LexicalContext
     end
 
     def invoke_1 vm
@@ -28,7 +31,8 @@ module Nydp
 
     def nydp_type ; "fn" ; end
     def to_s
-      "(closure #{context.inspect} : #{ifn.to_s})"
+      "(closure #{context.to_s} : #{ifn.to_s})"
     end
+    def inspect ; to_s ; end
   end
 end

data/lib/nydp/compiler.rb

@@ -9,9 +9,8 @@ module Nydp
 
     def self.compile expression, bindings
       compile_expr expression, bindings
-    rescue Exception => e
-      new_msg = "failed to compile expression #{expression.inspect},\nerror was #{e.message}"
-      raise $!, new_msg, $!.backtrace
+    rescue StandardError => e
+      raise Nydp::Error.new "failed to compile expression:\n#{expression.inspect}"
     end
 
     def self.compile_expr expression, bindings

data/lib/nydp/cond.rb

@@ -1,23 +1,20 @@
 module Nydp
   class ExecuteConditionalInstruction
     extend Helper
-    attr_reader :when_true, :when_false
 
     def initialize when_true, when_false
       @when_true, @when_false = when_true, when_false
     end
 
     def execute vm
-      truth = !Nydp::NIL.is?(vm.args.pop)
-      vm.instructions.push (truth ? when_true : when_false)
-      vm.contexts.push vm.current_context
+      (Nydp::NIL.is?(vm.args.pop) ? @when_false : @when_true).execute vm
     end
 
     def inspect
-      "when_true:#{when_true.inspect}:when_false:#{when_false.inspect}"
+      "when_true:#{@when_true.inspect}:when_false:#{@when_false.inspect}"
     end
     def to_s
-      "#{when_true.car.to_s} #{when_false.car.to_s}"
+      "#{@when_true.to_s} #{@when_false.to_s}"
     end
   end
 
@@ -33,26 +30,150 @@ module Nydp
     def execute vm
       vm.instructions.push conditional
       vm.contexts.push vm.current_context
-      vm.instructions.push condition
-      vm.contexts.push vm.current_context
+      condition.execute vm
     end
 
     def inspect
       "cond:#{condition.inspect}:#{conditional.inspect}"
     end
     def to_s
-      "(cond #{condition.car.to_s} #{conditional.to_s})"
+      "(cond #{condition.to_s} #{conditional.to_s})"
     end
 
     def self.build expressions, bindings
       if expressions.is_a? Nydp::Pair
-        cond       = cons Compiler.compile expressions.car, bindings
-        when_true  = cons Compiler.compile expressions.cdr.car, bindings
-        when_false = cons Compiler.compile expressions.cdr.cdr.car, bindings
-        new(cond, when_true, when_false)
+        cond       = Compiler.compile expressions.car, bindings
+        when_true  = Compiler.compile expressions.cdr.car, bindings
+        when_false = Compiler.compile expressions.cdr.cdr.car, bindings
+        csig       = sig(cond)
+        # puts cond_sig
+        # TODO : handle literal nil explicitly (if x y) -> #when_false is literal nil, we can hardcode that
+        # todo : handle "OR" explicitly -> (if x x y) -> when #cond equals #when_true, hardcode this case
+        case csig
+        when "LEX"
+          Cond_LEX.build(cond, when_true, when_false)
+        when "SYM"
+          Cond_SYM.new(cond, cons(when_true), cons(when_false))
+        else
+          new(cond, when_true, when_false)
+        end
       else
         raise "can't compile Cond: #{expr.inspect}"
       end
     end
   end
+
+  class CondBase
+    extend Helper
+    include Helper
+
+    def initialize cond, when_true, when_false
+      @condition, @when_true, @when_false = cond, when_true, when_false
+    end
+
+    def inspect ; "cond:#{@condition.inspect}:#{@when_true.inspect}:#{@when_false.inspect}" ; end
+    def to_s    ; "(cond #{@condition.to_s} #{@when_true.to_s} #{@when_false.to_s})" ; end
+  end
+
+  class Cond_LEX < CondBase
+    def execute vm
+      truth = !Nydp::NIL.is?(@condition.value vm.current_context)
+      vm.instructions.push (truth ? @when_true : @when_false)
+      vm.contexts.push vm.current_context
+    end
+
+    def self.build cond, when_true, when_false
+      tsig       = sig(when_true)
+      fsig       = sig(when_false)
+      cond_sig = "#{tsig}_#{fsig}"
+
+      # if (cond == when_true)
+      #   OR_LEX.build cond, when_false
+
+      if (cond == when_true) && (fsig == "LIT")
+        OR_LEX_LIT.new cond, nil, when_false
+      elsif (cond == when_true) && (fsig == "LEX")
+        OR_LEX_LEX.new cond, nil, when_false
+      else
+        case cond_sig
+        when "LIT_LIT"
+          Nydp::Cond_LEX_LIT_LIT.new(cond, when_true.expression, when_false.expression)
+        when "LEX_LIT"
+          Nydp::Cond_LEX_LEX_LIT.new(cond, when_true, when_false.expression)
+        when "CND_LIT"
+          Nydp::Cond_LEX_CND_LIT.new(cond, when_true, when_false.expression)
+        else
+          Nydp::Cond_LEX.new(cond, cons(when_true), cons(when_false))
+        end
+      end
+    end
+  end
+
+  class OR_LEX_LIT < CondBase
+    def execute vm
+      value = @condition.value vm.current_context
+      vm.push_arg(!Nydp::NIL.is?(value) ? value : @when_false)
+    end
+  end
+
+  class OR_LEX_LEX < CondBase
+    def execute vm
+      value = @condition.value vm.current_context
+      vm.push_arg(!Nydp::NIL.is?(value) ? value : (@when_false.value vm.current_context))
+    end
+  end
+
+  # class OR_LEX < CondBase
+  #   def execute vm
+  #     value = @condition.value vm.current_context
+  #     if !Nydp::NIL.is?(value)
+  #       vm.push_arg value
+  #     else
+  #       @when_false.execute vm
+  #     end
+  #   end
+
+  #   def self.build cond, when_false
+  #     case sig(when_false)
+  #     when "LIT"
+  #       OR_LEX_LIT.new(cond, nil, when_false)
+  #     when "LEX"
+  #       OR_LEX_LEX.new(cond, nil, when_false)
+  #     else
+  #       OR_LEX.new(cond, nil, when_false)
+  #     end
+  #   end
+  # end
+
+  class Cond_LEX_LIT_LIT < CondBase # (def no (arg) (cond arg nil t))
+    def execute vm
+      truth = !Nydp::NIL.is?(@condition.value vm.current_context)
+      vm.push_arg(truth ? @when_true : @when_false)
+    end
+  end
+
+  class Cond_LEX_LEX_LIT < CondBase
+    def execute vm
+      truth = !Nydp::NIL.is?(@condition.value vm.current_context)
+      vm.push_arg(truth ? (@when_true.value vm.current_context) : @when_false)
+    end
+  end
+
+  class Cond_LEX_CND_LIT < CondBase
+    def execute vm
+      if !Nydp::NIL.is?(@condition.value vm.current_context)
+        @when_true.execute vm
+      else
+        vm.push_arg @when_false
+      end
+    end
+  end
+
+  class Cond_SYM < CondBase
+    def execute vm
+      truth = !Nydp::NIL.is?(@condition.value)
+      vm.instructions.push (truth ? @when_true : @when_false)
+      vm.contexts.push vm.current_context
+    end
+  end
 end