nydp 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cb7040e607f04ac084dcf352dfe736d7c800d0b
-  data.tar.gz: 6c157638bebfa82f3b027ed38aa12dd1452b8396
+  metadata.gz: 6e7ea4e19c5b46b3a1c56299814f4412262c19ee
+  data.tar.gz: e812a2a39dab9ac0eb1a27b8cce1d6f0fd0b8f21
 SHA512:
-  metadata.gz: 231c62ab18da966168e4f1320f36bf9c1df91d9597cb4d68fee07bfac9b3e8ea8092ae9b1161a747483bc1711edfaa3985edcd1eeec2b7f59cc49825e63b8642
-  data.tar.gz: 96ab3742b6e55da13118b92ad3837517f7710e7fad80708361ca1f5909c0be726ec58ad8a57f48eef5a49610530a865bd325dc19cb860410665bda145da97cfd
+  metadata.gz: 6b65eac655935ae485b2c66e4e90f50dce3b5fcab5afb7f4c2394ae7f5a72b1451a65f24dadcb72460ad2e6f5b51a4e4c6ccbf7353ebc2d31aa8bc9294292d47
+  data.tar.gz: 95d9519c024596480c2a604db56055bfe6d5ec929c0b57a3c5356ff0b1150b92c698199f35116036c85ad0431d6d083918279abeab3640dbfa736af4b937f444

data/README.md

@@ -136,6 +136,9 @@ nydp > (pre-compile (parse "&foo"))
 ((fn (obj) (hash-get obj (quote foo))))
 
 nydp > (assign hsh { foo 1 bar 2 })
+nydp > (&bar hsh)
+2
+
 nydp > (&lastname (car german-composers))
 Bach
 
@@ -159,7 +162,7 @@ nydp > (parse "{ a 1 b 2 }")
 
 ```
 
-`brace-list` is a macro that expands to create a hash literal. It assumes every (2n+1)th items are literal symbol keys, and every (2(n+1))th item is the corresponding value which is evaluated at run time.
+`brace-list` is a macro that expands to create a hash literal. It assumes every item 0 is a literal symbol key, item 1 is the corresponding value which is evaluated at run time, and so on for each following item-pair.
 
 ```lisp
 
@@ -201,7 +204,7 @@ nydp > (with (a 1 b 2)
 ==> AND ALSO, Consider 3, the third (and final) thing
 ```
 
-By default, `string-pieces` is a function that just concatenates the string value of its arguments. You can redefine it as a macro to perform more fun stuff, or you can detect it within another macro to do extra-special stuff with it.
+By default, `string-pieces` is a function that just concatenates the string value of its arguments. You can redefine it as a macro to perform more fun stuff, or you can detect it within another macro to do extra-special stuff with it. The 'nydp-html gem detects 'string-pieces and gives it special treatment in order to render haml and textile efficiently, and also to capture and report errors inside interpolations and report them correctly.
 
 
 #### 5. No continuations.
@@ -210,7 +213,14 @@ Sorry. While technically possible ... why bother?
 
 #### 6. No argument destructuring
 
-However, this doesn't need to be built-in, it can be done with macros alone.
+However, this doesn't need to be built-in, it can be done with macros alone. On the other hand, "rest" arguments are implicitly available using the same syntax as Arc uses:
+
+```lisp
+(def fun (a b . others) ...)
+```
+
+In this example, `'others` is either nil, or a list containing the third and subsequent arguments to the call to `'fun`. For many examples of this kind of invocation, see [invocation-tests](lib/lisp/tests/invocation-tests.nydp) in the `tests` directory.
+
 
 
 ## Besides that, what can Nydp do?
@@ -232,14 +242,14 @@ elsif c
 else  e
 ```
 
-#### 5. Lexically scoped, but with macros to define dynamic variables backed by ruby threadlocals.
+#### 5. Lexically scoped, but dynamic variables possible, using thread-locals
 
 ```lisp
-nydp> (dynamic foo)
+nydp> (dynamic foo) ;; declares 'foo as a dynamic variable
 
 nydp> (def do-something () (+ (foo) 1))
 
-nydp> (w/foo 99 (do-something))
+nydp> (w/foo 99 (do-something)) ;; sets 'foo to 99 for the duration of the call to 'do-something, will set it back to its previous value afterwards.
 
 ==> 100
 

data/lib/lisp/core-06-benchmarking.nydp

@@ -0,0 +1,42 @@
+(def bm-pythag ()
+  (for i 1 50
+    (for j 1 50
+      (sqrt (+ (* i i) (* j j))))))
+
+(def bm-repeat (f n)
+  (for b 1 n (f)))
+
+(def bm (desc f repeats iterations)
+     (p "\n================================================")
+     (p "Benchmark: ~desc - ~repeats runs of ~iterations iterations each")
+     (let times 0
+          (for reps 1 repeats
+               (let time (millisecs)
+                    (bm-repeat f iterations)
+                    (let elapsed (- (millisecs) time)
+                         (assign times (+ elapsed times))
+                         (p "  took: ~elapsed ms, ~(/ elapsed iterations) ms per iteration"))))
+          (p "total ~(just times), average ~(/ times repeats) per run")
+          (p "================================================\n"))
+     nil)
+
+(let private-x 0
+     (let inc-x (fn () (assign private-x (+ 1 private-x)))
+          (def bm-zero-arg-call ()
+               (for i 0 400 (inc-x)))))
+
+(let private-y 0
+     (let inc-y (fn (n) (assign private-y (+ n private-y)))
+          (def bm-one-arg-call ()
+               (for i 0 400 (inc-y 10)))))
+
+(let private-z 0
+     (let inc-z (fn (n m) (assign private-z (+ (* n m) private-z)))
+          (def bm-two-arg-call ()
+               (for i 0 400 (inc-z 2 5)))))
+
+(def rbs ()
+  (bm "pythag"        bm-pythag        10 100)
+  (bm "zero arg call" bm-zero-arg-call 10 500)
+  (bm "one arg call"  bm-one-arg-call  10 500)
+  (bm "two arg call"  bm-two-arg-call  10 500))

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

@@ -0,0 +1,119 @@
+;; test that basic function invocation works for various combinations
+;; of parameter lists and invocation arguments
+;;
+;; important mostly because these kind of calls are subject to the
+;; most aggressive optimisation so it's useful to have a quick
+;; smoke test to check that nothing obvious is broken
+;;
+
+(def tst-0   ()               "success"                                                  )
+(def tst-0-n n                "success n: ~(inspect n)"                                  )
+(def tst-1   (a)              "success a: ~a"                                            )
+(def tst-1-n (a . n)          "success a: ~a . n: ~(inspect n)"                          )
+(def tst-2   (a b)            "success a: ~a b: ~b"                                      )
+(def tst-2-n (a b . n)        "success a: ~a b: ~b . n: ~(inspect n)"                    )
+(def tst-3   (a b c)          "success a: ~a b: ~b c: ~c"                                )
+(def tst-3-n (a b c . n)      "success a: ~a b: ~b c: ~c . n: ~(inspect n)"              )
+(def tst-4   (a b c d)        "success a: ~a b: ~b c: ~c d: ~d"                          )
+(def tst-4-n (a b c d . n)    "success a: ~a b: ~b c: ~c d: ~d . n: ~(inspect n)"        )
+(def tst-5   (a b c d e)      "success a: ~a b: ~b c: ~c d: ~d e: ~e"                    )
+(def tst-5-n (a b c d e . n)  "success a: ~a b: ~b c: ~c d: ~d e: ~e . n: ~(inspect n)"  )
+
+(register-test
+ '(suite "Invocation Tests"
+         (suite "zero-params"
+                ("no args"     (tst-0)               "success" )
+                ("one arg"     (tst-0 1)             "success" )
+                ("two args"    (tst-0 1 2)           "success" )
+                ("three args"  (tst-0 1 2 3)         "success" )
+                ("four args"   (tst-0 1 2 3 4)       "success" )
+                ("five args"   (tst-0 1 2 3 4 5)     "success" ))
+
+         (suite "single rest-param"
+                ("no args"     (tst-0-n)             "success n: nil"         )
+                ("one arg"     (tst-0-n 1)           "success n: (1)"         )
+                ("two args"    (tst-0-n 1 2)         "success n: (1 2)"       )
+                ("three args"  (tst-0-n 1 2 3)       "success n: (1 2 3)"     )
+                ("four args"   (tst-0-n 1 2 3 4)     "success n: (1 2 3 4)"   )
+                ("five args"   (tst-0-n 1 2 3 4 5)   "success n: (1 2 3 4 5)" ))
+
+         (suite "single param"
+                ("no args"     (tst-1)               "success a: "  )
+                ("one arg"     (tst-1 1)             "success a: 1" )
+                ("two args"    (tst-1 1 2)           "success a: 1" )
+                ("three args"  (tst-1 1 2 3)         "success a: 1" )
+                ("four args"   (tst-1 1 2 3 4)       "success a: 1" )
+                ("five args"   (tst-1 1 2 3 4 5)     "success a: 1" ))
+
+         (suite "single param and rest param"
+                ("no args"     (tst-1-n)             "success a:  . n: nil"        )
+                ("one arg"     (tst-1-n 1)           "success a: 1 . n: nil"       )
+                ("two args"    (tst-1-n 1 2)         "success a: 1 . n: (2)"       )
+                ("three args"  (tst-1-n 1 2 3)       "success a: 1 . n: (2 3)"     )
+                ("four args"   (tst-1-n 1 2 3 4)     "success a: 1 . n: (2 3 4)"   )
+                ("five args"   (tst-1-n 1 2 3 4 5)   "success a: 1 . n: (2 3 4 5)" ))
+
+         (suite "two params"
+                ("no args"     (tst-2)               "success a:  b: "   )
+                ("one arg"     (tst-2 1)             "success a: 1 b: "  )
+                ("two args"    (tst-2 1 2)           "success a: 1 b: 2" )
+                ("three args"  (tst-2 1 2 3)         "success a: 1 b: 2" )
+                ("four args"   (tst-2 1 2 3 4)       "success a: 1 b: 2" )
+                ("five args"   (tst-2 1 2 3 4 5)     "success a: 1 b: 2" ))
+
+         (suite "two params and rest param"
+                ("no args"     (tst-2-n)             "success a:  b:  . n: nil"       )
+                ("one arg"     (tst-2-n 1)           "success a: 1 b:  . n: nil"      )
+                ("two args"    (tst-2-n 1 2)         "success a: 1 b: 2 . n: nil"     )
+                ("three args"  (tst-2-n 1 2 3)       "success a: 1 b: 2 . n: (3)"     )
+                ("four args"   (tst-2-n 1 2 3 4)     "success a: 1 b: 2 . n: (3 4)"   )
+                ("five args"   (tst-2-n 1 2 3 4 5)   "success a: 1 b: 2 . n: (3 4 5)" ))
+
+         (suite "three params"
+                ("no args"     (tst-3)               "success a:  b:  c: "    )
+                ("one arg"     (tst-3 1)             "success a: 1 b:  c: "   )
+                ("two args"    (tst-3 1 2)           "success a: 1 b: 2 c: "  )
+                ("three args"  (tst-3 1 2 3)         "success a: 1 b: 2 c: 3" )
+                ("four args"   (tst-3 1 2 3 4)       "success a: 1 b: 2 c: 3" )
+                ("five args"   (tst-3 1 2 3 4 5)     "success a: 1 b: 2 c: 3" ))
+
+         (suite "three params and rest param"
+                ("no args"     (tst-3-n)             "success a:  b:  c:  . n: nil"      )
+                ("one arg"     (tst-3-n 1)           "success a: 1 b:  c:  . n: nil"     )
+                ("two args"    (tst-3-n 1 2)         "success a: 1 b: 2 c:  . n: nil"    )
+                ("three args"  (tst-3-n 1 2 3)       "success a: 1 b: 2 c: 3 . n: nil"   )
+                ("four args"   (tst-3-n 1 2 3 4)     "success a: 1 b: 2 c: 3 . n: (4)"   )
+                ("five args"   (tst-3-n 1 2 3 4 5)   "success a: 1 b: 2 c: 3 . n: (4 5)" ))
+
+         (suite "four params"
+                ("no args"     (tst-4)               "success a:  b:  c:  d: "     )
+                ("one arg"     (tst-4 1)             "success a: 1 b:  c:  d: "    )
+                ("two args"    (tst-4 1 2)           "success a: 1 b: 2 c:  d: "   )
+                ("three args"  (tst-4 1 2 3)         "success a: 1 b: 2 c: 3 d: "  )
+                ("four args"   (tst-4 1 2 3 4)       "success a: 1 b: 2 c: 3 d: 4" )
+                ("five args"   (tst-4 1 2 3 4 5)     "success a: 1 b: 2 c: 3 d: 4" ))
+
+         (suite "four params and rest param"
+                ("no args"     (tst-4-n)             "success a:  b:  c:  d:  . n: nil"     )
+                ("one arg"     (tst-4-n 1)           "success a: 1 b:  c:  d:  . n: nil"    )
+                ("two args"    (tst-4-n 1 2)         "success a: 1 b: 2 c:  d:  . n: nil"   )
+                ("three args"  (tst-4-n 1 2 3)       "success a: 1 b: 2 c: 3 d:  . n: nil"  )
+                ("four args"   (tst-4-n 1 2 3 4)     "success a: 1 b: 2 c: 3 d: 4 . n: nil" )
+                ("five args"   (tst-4-n 1 2 3 4 5)   "success a: 1 b: 2 c: 3 d: 4 . n: (5)" ))
+
+         (suite "five params"
+                ("no args"     (tst-5)               "success a:  b:  c:  d:  e: "      )
+                ("one arg"     (tst-5 1)             "success a: 1 b:  c:  d:  e: "     )
+                ("two args"    (tst-5 1 2)           "success a: 1 b: 2 c:  d:  e: "    )
+                ("three args"  (tst-5 1 2 3)         "success a: 1 b: 2 c: 3 d:  e: "   )
+                ("four args"   (tst-5 1 2 3 4)       "success a: 1 b: 2 c: 3 d: 4 e: "  )
+                ("five args"   (tst-5 1 2 3 4 5)     "success a: 1 b: 2 c: 3 d: 4 e: 5" ))
+
+         (suite "five params and rest param"
+                ("no args"     (tst-5-n)             "success a:  b:  c:  d:  e:  . n: nil"      )
+                ("one arg"     (tst-5-n 1)           "success a: 1 b:  c:  d:  e:  . n: nil"     )
+                ("two args"    (tst-5-n 1 2)         "success a: 1 b: 2 c:  d:  e:  . n: nil"    )
+                ("three args"  (tst-5-n 1 2 3)       "success a: 1 b: 2 c: 3 d:  e:  . n: nil"   )
+                ("four args"   (tst-5-n 1 2 3 4)     "success a: 1 b: 2 c: 3 d: 4 e:  . n: nil"  )
+                ("five args"   (tst-5-n 1 2 3 4 5)   "success a: 1 b: 2 c: 3 d: 4 e: 5 . n: nil" ))
+         ))

data/lib/nydp/builtin.rb

@@ -3,13 +3,34 @@ require 'nydp/error'
 
 module Nydp::Builtin
   module Base
+    include Nydp::Helper
+
+    def invoke_1 vm
+      invoke vm, Nydp.NIL
+    end
+
+    def invoke_2 vm, arg
+      invoke vm, cons(arg)
+    end
+
+    def invoke_3 vm, arg_0, arg_1
+      invoke vm, cons(arg_0, cons(arg_1))
+    end
+
     def invoke vm, args
       builtin_invoke vm, args
-    rescue Nydp::Error => ne
-      raise ne
     rescue Exception => e
-      new_msg = "Called #{self.inspect}\nwith args #{args.inspect}\nraised\n#{Nydp.indent_text e.message}"
-      raise $!, new_msg, $!.backtrace
+      handle_error e, args
+    end
+
+    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
+      end
     end
 
     def name

data/lib/nydp/builtin/hash.rb

@@ -17,9 +17,15 @@ class Nydp::Builtin::HashGet
     case hash
     when Nydp::Hash
       vm.push_arg(hash[key] || Nydp.NIL)
+    when NilClass, Nydp.NIL
+      vm.push_arg Nydp.NIL
     else
-      key = n2r args.cdr.car
-      vm.push_arg(r2n hash[key], ns)
+      if hash.respond_to? :[]
+        key = n2r args.cdr.car
+        vm.push_arg(r2n hash[key], ns)
+      else
+        raise "hash-get: Not a hash: #{hash.class.name}"
+      end
     end
   end
 end
@@ -33,8 +39,14 @@ class Nydp::Builtin::HashSet
     case hash
     when Nydp::Hash
       hash[key] = value
+    when NilClass, Nydp.NIL
+      nil
     else
-      hash[n2r key] = n2r value
+      if hash.respond_to?(:[]=)
+        hash[n2r key] = n2r value
+      else
+        raise "hash-set: Not a hash: #{hash.class.name}"
+      end
     end
     vm.push_arg value
   end

data/lib/nydp/builtin/pre_compile.rb

@@ -2,6 +2,7 @@ class Nydp::Builtin::PreCompile
   include Nydp::Builtin::Base
 
   def builtin_invoke vm, args
+    raise Nydp:Error.new("pre-compile: expects one arg, got #{args.inspect}") unless Nydp.NIL == args.cdr
     vm.push_arg args.car
   end
 end

data/lib/nydp/closure.rb

@@ -6,6 +6,18 @@ module Nydp
       @ifn, @context = ifn, context
     end
 
+    def invoke_1 vm
+      ifn.invoke_1 vm, context
+    end
+
+    def invoke_2 vm, arg
+      ifn.invoke_2 vm, context, arg
+    end
+
+    def invoke_3 vm, arg_0, arg_1
+      ifn.invoke_3 vm, context, arg_0, arg_1
+    end
+
     def invoke vm, arg_values
       ifn.invoke vm, context, arg_values
     end

data/lib/nydp/function_invocation.rb

@@ -2,38 +2,93 @@ module Nydp
   class InvocationFailed < StandardError
   end
 
-  class InvokeFunctionInstruction
-    def initialize arg_count, source_expression
-      @source_expression = source_expression
-      @arg_count = arg_count
+  module Invocation
+    class Base
+      include Helper
+      def initialize source_expression
+        @source_expression = source_expression
+      end
+
+      def handle e, f, args
+        case e
+        when Nydp::Error, InvocationFailed
+          raise e
+        else
+          msg  =  "failed to execute invocation #{f.inspect} #{args.inspect}"
+          msg +=  "\nsource was #{source.inspect}"
+          msg +=  "\nfunction name was #{source.car.inspect}"
+          i_f = InvocationFailed.new "#{msg}\n#{e.message}"
+          i_f.set_backtrace e.backtrace
+          raise i_f
+        end
+      end
+
+      def inspect ; source.inspect     ; end
+      def source  ; @source_expression ; end
+      def to_s    ; source.to_s        ; end
     end
 
-    def execute vm
-      args = vm.pop_args @arg_count
-      args.car.invoke vm, args.cdr
-    rescue Nydp::Error => ne
-      raise ne
-    rescue InvocationFailed => i_f
-      raise i_f
-    rescue Exception => e
-      msg  =  "failed to execute invocation #{args.inspect}"
-      msg +=  "\nsource was #{source.inspect}"
-      msg +=  "\nfunction name was #{source.car.inspect}"
-      i_f = InvocationFailed.new "#{msg}\n#{e.message}"
-      i_f.set_backtrace e.backtrace
-      raise i_f
-    end
-
-    def inspect ; source.inspect     ; end
-    def source  ; @source_expression ; end
-    def to_s    ; source.to_s        ; end
+    class Invocation_1 < Invocation::Base
+      def execute vm
+        f = vm.pop_arg
+        f.invoke_1 vm
+      rescue Exception => e
+        handle e, f, Nydp.NIL
+      end
+    end
+
+    class Invocation_2 < Invocation::Base
+      def execute vm
+        arg = vm.pop_arg
+        f   = vm.pop_arg
+        f.invoke_2 vm, arg
+      rescue Exception => e
+        handle e, f, cons(arg)
+      end
+    end
+
+    class Invocation_3 < Invocation::Base
+      def execute vm
+        arg_1 = vm.pop_arg
+        arg_0 = vm.pop_arg
+        f   = vm.pop_arg
+        f.invoke_3 vm, arg_0, arg_1
+      rescue Exception => e
+        handle e, f, cons(arg_0, cons(arg_1))
+      end
+    end
+
+    class Invocation_N < Invocation::Base
+      def initialize arg_count, source_expression
+        super source_expression
+        @arg_count = arg_count
+      end
+
+      def execute vm
+        args = vm.pop_args @arg_count
+        args.car.invoke vm, args.cdr
+      rescue Exception => e
+        handle e, args.car, args.cdr
+      end
+    end
   end
 
   class FunctionInvocation
     extend Helper
 
     def self.build expression, bindings
-      new cons(InvokeFunctionInstruction.new(expression.size, expression)), Compiler.compile_each(expression, bindings), expression
+      compiled   = Compiler.compile_each(expression, bindings)
+      invocation = cons case expression.size
+                        when 1
+                          Invocation::Invocation_1.new(expression)
+                        when 2
+                          Invocation::Invocation_2.new(expression)
+                        when 3
+                          Invocation::Invocation_3.new(expression)
+                        else
+                          Invocation::Invocation_N.new(expression.size, expression)
+                        end
+      new invocation, compiled, expression
     end
 
     def initialize function_instruction, argument_instructions, source

data/lib/nydp/interpreted_function.rb

@@ -1,30 +1,39 @@
 require 'nydp/lexical_context'
+require 'nydp/lexical_context_builder'
 require 'nydp/closure'
 
 module Nydp
   class PopArg
-    def self.execute vm
-      vm.pop_arg
-    end
-
-    def self.to_s
-      ""
-    end
-
-    def self.inspect
-      "#pop_arg"
-    end
+    def self.execute vm ; vm.pop_arg ; end
+    def self.to_s       ; ""         ; end
+    def self.inspect    ; "#pop_arg" ; end
   end
 
   class InterpretedFunction
     include Helper
     extend Helper
 
-    attr_accessor :arg_names, :body
+    attr_accessor :arg_names, :body, :context_builder
+
+    def invoke_1 vm, parent_context
+      vm.push_instructions self.body, LexicalContext.new(parent_context)
+    end
+
+    def invoke_2 vm, parent_context, arg
+      lc = LexicalContext.new parent_context
+      set_args_1 lc, arg
+      vm.push_instructions self.body, lc
+    end
+
+    def invoke_3 vm, parent_context, arg_0, arg_1
+      lc = LexicalContext.new parent_context
+      set_args_2 lc, arg_0, arg_1
+      vm.push_instructions self.body, lc
+    end
 
     def invoke vm, parent_context, arg_values
       lc = LexicalContext.new parent_context
-      setup_context lc, arg_names, arg_values
+      set_args lc, arg_values
       vm.push_instructions self.body, lc
     end
 
@@ -42,6 +51,8 @@ module Nydp
       index_parameters arg_list, my_params
       ifn = Nydp::InterpretedFunction.new
       ifn.arg_names = arg_list
+      ifn.extend Nydp::LexicalContextBuilder.select arg_list
+      ifn.initialize_names arg_list
       ifn.body = compile_body body, cons(my_params, bindings), []
       ifn
     end

data/lib/nydp/lexical_context.rb

@@ -1,4 +1,5 @@
 class Nydp::LexicalContext
+  include Nydp::Helper
   attr_reader :names, :values, :parent
 
   def initialize parent
@@ -31,6 +32,23 @@ class Nydp::LexicalContext
     values << value
   end
 
+  def set_args_1 names, arg
+    if pair? names
+      set names.car, arg
+    elsif Nydp.NIL.isnt? names
+      set names, cons(arg)
+    end
+  end
+
+  def set_args_2 names, arg_0, arg_1
+    if pair? names
+      set names.car, arg_0
+      set_args_1 names.cdr, arg_1
+    elsif Nydp.NIL.isnt? names
+      set names, cons(arg_0, cons(arg_1))
+    end
+  end
+
   def set_index index, value
     values[index] = value
   end

data/lib/nydp/lexical_context_builder.rb

@@ -0,0 +1,130 @@
+module Nydp::LexicalContextBuilder
+  extend Nydp::Helper
+
+  module B_0
+    def initialize_names _        ; end
+    def set_args_1 lc, a          ; end
+    def set_args_2 lc, a_0, a_1   ; end
+    def set_args   lc, args       ; end
+  end
+
+  module B_1
+    def initialize_names names      ; @param_name = names.car                      ; end
+    def set_args_1 lc, arg          ; lc.set @param_name, arg                      ; end
+    def set_args_2 lc, arg_0, arg_1 ; lc.set @param_name, arg_0                    ; end
+    def set_args   lc, args         ; lc.set @param_name, args.car                 ; end
+  end
+
+  module B_2
+    def initialize_names names
+      @param_name_0 = names.car
+      @param_name_1 = names.cdr.car
+    end
+    def set_args_1 lc, arg
+      lc.set @param_name_0, arg
+    end
+    def set_args_2 lc, arg_0, arg_1
+      lc.set @param_name_0, arg_0
+      lc.set @param_name_1, arg_1
+    end
+    def set_args lc, args
+      lc.set @param_name_0, args.car
+      lc.set @param_name_1, args.cdr.car
+    end
+  end
+
+  module B_0_Rest
+    include Nydp::Helper
+    def initialize_names names      ; @param_name = names                          ; end
+    def set_args_1 lc, arg          ; lc.set @param_name, cons(arg)                ; end
+    def set_args_2 lc, arg_0, arg_1 ; lc.set @param_name, cons(arg_0, cons(arg_1)) ; end
+    def set_args   lc, args         ; lc.set @param_name, args                     ; end
+  end
+
+  module B_1_Rest
+    include Nydp::Helper
+    def initialize_names names
+      @param_name_0 = names.car
+      @param_name_1 = names.cdr
+    end
+    def set_args_1 lc, arg
+      lc.set @param_name_0, arg
+    end
+    def set_args_2 lc, arg_0, arg_1
+      lc.set @param_name_0, arg_0
+      lc.set @param_name_1, cons(arg_1)
+    end
+    def set_args lc, args
+      lc.set @param_name_0, args.car
+      lc.set @param_name_1, args.cdr
+    end
+  end
+
+  module B_2_Rest
+    def initialize_names names
+      @param_name_0 = names.car
+      @param_name_1 = names.cdr.car
+      @param_name_2 = names.cdr.cdr
+    end
+    def set_args_1 lc, arg
+      lc.set @param_name_0, arg
+    end
+    def set_args_2 lc, arg_0, arg_1
+      lc.set @param_name_0, arg_0
+      lc.set @param_name_1, arg_1
+    end
+    def set_args lc, args
+      lc.set @param_name_0, args.car
+      lc.set @param_name_1, args.cdr.car
+      lc.set @param_name_2, args.cdr.cdr
+    end
+  end
+
+  module B_X
+    def initialize_names names
+      @param_names = names
+    end
+    def set_args_1 lc, arg
+      lc.set @param_names.car, arg
+    end
+    def set_args_2 lc, arg_0, arg_1
+      lc.set @param_names.car,     arg_0
+      lc.set @param_names.cdr.car, arg_1
+    end
+    def set_args lc, args
+      _set_args lc, @param_names, args
+    end
+    def _set_args lc, names, args
+      unless Nydp.NIL.is? names
+        lc.set names.car, args.car
+        _set_args lc, names.cdr, args.cdr
+      end
+    end
+  end
+
+  module B_X_Rest
+    include Nydp::Helper
+    def initialize_names names      ; @param_names = names                        ; end
+    def set_args_1 lc, arg          ; set_args lc, cons(arg)                ; end
+    def set_args_2 lc, arg_0, arg_1 ; set_args lc, cons(arg_0, cons(arg_1)) ; end
+    def set_args lc, args           ; _set_args lc, @param_names, args            ; end
+    def _set_args lc, names, args
+      if pair? names
+        lc.set names.car, args.car
+        _set_args lc, names.cdr, args.cdr
+      elsif Nydp.NIL.isnt? names
+        lc.set names, args
+      end
+    end
+  end
+
+  def self.select arg_names
+    if pair? arg_names
+      size = pair?(arg_names) ? arg_names.size : 0
+      class_name = "B_#{size > 2 ? "X" : size}#{arg_names.proper? ? "" : "_Rest"}"
+    else
+      class_name = "B_0_Rest"
+    end
+    self.const_get(class_name.to_sym)
+  end
+end

data/lib/nydp/pair.rb

@@ -55,6 +55,10 @@ class Nydp::Pair
     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)

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.0.11"
+  VERSION = "0.0.12"
 end

data/spec/hash_spec.rb

@@ -153,4 +153,74 @@ describe Nydp::Hash do
       end
     end
   end
+
+  describe "get/set nil" do
+    let(:ahash) { Nydp.NIL }
+
+    describe "hash set" do
+      it "does nothing, returns its value" do
+        k    = Nydp::Symbol.mk "keysym", ns
+        v    = Nydp::StringAtom.new "foobar"
+        args = pair_list [ahash, k, v]
+        Nydp::Builtin::HashSet.new.invoke vm, args
+
+        expect(ahash).     to eq Nydp.NIL
+        expect(vm.pop_arg).to eq v
+      end
+    end
+
+    describe "hash get" do
+      it "converts ruby value to nydp value" do
+        k    = Nydp::Symbol.mk "keysym", ns
+        args           = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
+    end
+  end
+
+  describe "non-hash" do
+    let(:ahash) { Nydp::StringAtom.new "this here ain't no hash, hombre" }
+
+    describe "hash set" do
+      it "does nothing, returns its value" do
+        k    = Nydp::Symbol.mk "keysym", ns
+        v    = Nydp::StringAtom.new "foobar"
+        args = pair_list [ahash, k, v]
+
+        begin
+          Nydp::Builtin::HashSet.new.invoke vm, args
+        rescue Exception => e
+          error = e
+        end
+
+        expect(error.message.gsub(/at \/.*:in `builtin_invoke'/, '<error info>')).to eq "Called builtin/hash-set
+with args (\"this here ain't no hash, hombre\" keysym \"foobar\")
+raised
+  hash-set: Not a hash: Nydp::StringAtom
+<error info>"
+      end
+    end
+
+    describe "hash get" do
+      it "converts ruby value to nydp value" do
+        k    = Nydp::Symbol.mk "keysym", ns
+        args           = [ ahash, k ]
+
+        begin
+          Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        rescue Exception => e
+          error = e
+        end
+
+        expect(error.message.gsub(/at \/.*:in `builtin_invoke'/, '<error info>')).to eq "Called builtin/hash-get
+with args (\"this here ain't no hash, hombre\" keysym)
+raised
+  hash-get: Not a hash: Nydp::StringAtom
+<error info>"
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-11 00:00:00.000000000 Z
+date: 2015-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,11 +90,13 @@ files:
 - lib/lisp/core-03-syntax.nydp
 - lib/lisp/core-04-utils.nydp
 - lib/lisp/core-05-test-runner.nydp
+- lib/lisp/core-06-benchmarking.nydp
 - lib/lisp/tests/boot-tests.nydp
 - lib/lisp/tests/builtin-tests.nydp
 - lib/lisp/tests/dynamic-scope-test.nydp
 - lib/lisp/tests/error-tests.nydp
 - lib/lisp/tests/foundation-test.nydp
+- lib/lisp/tests/invocation-tests.nydp
 - lib/lisp/tests/parser-tests.nydp
 - lib/nydp.rb
 - lib/nydp/assignment.rb
@@ -148,6 +150,7 @@ files:
 - lib/nydp/helper.rb
 - lib/nydp/interpreted_function.rb
 - lib/nydp/lexical_context.rb
+- lib/nydp/lexical_context_builder.rb
 - lib/nydp/literal.rb
 - lib/nydp/pair.rb
 - lib/nydp/parser.rb