nydp 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc628274c2cf2f44cd05559766575d3cc9920d69
-  data.tar.gz: 619d6083cf6dab728793950bbc005fe3b281be56
+  metadata.gz: ab2e8ff02992658d66f96d3744cf872ece5e0c6c
+  data.tar.gz: ca9cb9b175abd201e722d7f6a60a334d164bb442
 SHA512:
-  metadata.gz: 391b384008f3e7e23505cb0871ab667435aea31a0841f71f3572316bdf1fc731a142f6dff7f0e2be26cf2eb60750bd60cf8ae89f298f9670f387b24fa2fd6141
-  data.tar.gz: 4390de26c600a52fbcf82bd91045acd3ed8791aeddcbec340cd227982632a28cdf2cbb1db42f2608f48b04010d3526870d5bfbfcc8161bf6601edd290394b5e5
+  metadata.gz: 31f1534694189aaec724cf8f49c1de8a98c07c50d2a94fef0737d331f8f11b054d860c64fed579365f4715cb8c6b8f3dce8de896e243ebf577aa8dc826e72d03
+  data.tar.gz: e93101eeae01cbed4c07a051de5ff7bba66b9962e92636c349c934cb7f788e6c322b3c00a64c348bdbe027c64ae67e80e67b5eac44148d851d8e37f34669e966

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

@@ -1,104 +1,104 @@
-(def bm-cond ()
-  (if (< 3 5) "less" "more"))
+;; (def bm-cond ()
+;;   (if (< 3 5) "less" "more"))
 
-(def bm-cond-lex (var)
-  (if var "present" "absent"))
+;; (def bm-cond-lex (var)
+;;   (if var "present" "absent"))
 
-(def bm-cond-sym ()
-  (if bm-cond-sym-value "present" "absent"))
+;; (def bm-cond-sym ()
+;;   (if bm-cond-sym-value "present" "absent"))
 
-(def bm-cond-3 ()
-  (bm-cond-lex 1)
-  (bm-cond-lex nil))
+;; (def bm-cond-3 ()
+;;   (bm-cond-lex 1)
+;;   (bm-cond-lex nil))
 
-(def bm-cond-4 ()
-  (assign bm-cond-sym-value 1)
-  (bm-cond-sym)
-  (assign bm-cond-sym-value nil)
-  (bm-cond-sym))
+;; (def bm-cond-4 ()
+;;   (assign bm-cond-sym-value 1)
+;;   (bm-cond-sym)
+;;   (assign bm-cond-sym-value nil)
+;;   (bm-cond-sym))
 
-(def bm-cond-LEX-LEX-LIT (a b)
-  (if a b nil))
+;; (def bm-cond-LEX-LEX-LIT (a b)
+;;   (if a b nil))
 
-(def bm-cond-LEX-CND-LIT (a)
-  (if a (if (< a 3) "yes" "no") "other"))
+;; (def bm-cond-LEX-CND-LIT (a)
+;;   (if a (if (< a 3) "yes" "no") "other"))
 
-(def bm-cond-6 ()
-  (if (< 3 5) (+ 3 5) (- 3 5)))
+;; (def bm-cond-6 ()
+;;   (if (< 3 5) (+ 3 5) (- 3 5)))
 
-(def bm-cond-7 ()
-  (bm-cond-LEX-CND-LIT nil)
-  (bm-cond-LEX-CND-LIT 1)
-  (bm-cond-LEX-CND-LIT 5))
+;; (def bm-cond-7 ()
+;;   (bm-cond-LEX-CND-LIT nil)
+;;   (bm-cond-LEX-CND-LIT 1)
+;;   (bm-cond-LEX-CND-LIT 5))
 
-(def bm-cond-5 ()
-  (bm-cond-LEX-LEX-LIT 1 2)
-  (bm-cond-LEX-LEX-LIT nil 3))
+;; (def bm-cond-5 ()
+;;   (bm-cond-LEX-LEX-LIT 1 2)
+;;   (bm-cond-LEX-LEX-LIT nil 3))
 
-(def bm-cond-OR (x)
-  (if x x "no"))
+;; (def bm-cond-OR (x)
+;;   (if x x "no"))
 
-(def bm-cond-OR2 (x y z)
-  (if x x (if y y z)))
+;; (def bm-cond-OR2 (x y z)
+;;   (if x x (if y y z)))
 
-(def bm-cond-8 ()
-  (bm-cond-OR 1)
-  (bm-cond-OR nil))
+;; (def bm-cond-8 ()
+;;   (bm-cond-OR 1)
+;;   (bm-cond-OR nil))
 
-(def bm-cond-OR-LEX-LEX (x y)
-  (if x x y))
+;; (def bm-cond-OR-LEX-LEX (x y)
+;;   (if x x y))
 
-(def bm-cond-9 ()
-  (bm-cond-OR-LEX-LEX 1)
-  (bm-cond-OR-LEX-LEX nil))
+;; (def bm-cond-9 ()
+;;   (bm-cond-OR-LEX-LEX 1)
+;;   (bm-cond-OR-LEX-LEX nil))
 
-(def bm-cond-10 ()
-  (bm-cond-OR2 1 2 3)
-  (bm-cond-OR2 nil 2 3)
-  (bm-cond-OR2 nil nil 3)
-  (bm-cond-OR2 nil nil nil))
+;; (def bm-cond-10 ()
+;;   (bm-cond-OR2 1 2 3)
+;;   (bm-cond-OR2 nil 2 3)
+;;   (bm-cond-OR2 nil nil 3)
+;;   (bm-cond-OR2 nil nil nil))
 
-(def bm-cond-lex-lit-lit ()
-  (no nil)
-  (no 1))
+;; (def bm-cond-lex-lit-lit ()
+;;   (no nil)
+;;   (no 1))
 
-(def bm-faster-do ()
-  (each x '(0 1 2 3 4 5 6 7 8 9) ;; each uses 'do internally
-    x))
+;; (def bm-faster-do ()
+;;   (each x '(0 1 2 3 4 5 6 7 8 9) ;; each uses 'do internally
+;;     x))
 
-(def bm-pythag ()
-  (for i 1 50
-    (for j 1 50
-      (sqrt (+ (* i i) (* j j))))))
+;; (def bm-pythag ()
+;;   (for i 1 50
+;;     (for j 1 50
+;;       (sqrt (+ (* i i) (* j j))))))
 
-(def bm-len-str ()
-  (len "abcd"))
+;; (def bm-len-str ()
+;;   (len "abcd"))
 
-(def bm-len-pair ()
-  (len '(a b c d)))
+;; (def bm-len-pair ()
+;;   (len '(a b c d)))
 
-(def bm-len-hash ()
-  (len {a 1}))
+;; (def bm-len-hash ()
+;;   (len {a 1}))
 
-(def bm-len-fn ()
-  (len list))
+;; (def bm-len-fn ()
+;;   (len list))
 
-(def bm-repeat (f n)
-  (for b 1 n (f)))
+;; (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 started (time)
-                    (bm-repeat f iterations)
-                    (let elapsed (- (time) started)
-                         (assign times (+ elapsed times))
-                         (p "  took: ~elapsed ms, ~(/ elapsed iterations) ms per iteration"))))
-          (p "total ~(just times), average ~(/ times repeats) per run")
-          (p "================================================\n")
-          "~desc : total ~(just times), average ~(/ times repeats) per run"))
+;; (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 started (time)
+;;                     (bm-repeat f iterations)
+;;                     (let elapsed (- (time) started)
+;;                          (assign times (+ elapsed times))
+;;                          (p "  took: ~elapsed ms, ~(/ elapsed iterations) ms per iteration"))))
+;;           (p "total ~(just times), average ~(/ times repeats) per run")
+;;           (p "================================================\n")
+;;           "~desc : total ~(just times), average ~(/ times repeats) per run"))
 
 ;; (assign a 1)
 ;; (assign b 1)
@@ -162,22 +162,17 @@
 ;;   (for i 1 10
 ;;        (pre-compile (dox-src rbs))))
 
-;; (def bm-hash-fill
-;;   (let h {}
-;;     (=h.aa 1) (=h.ab 2) (=h.ac 3) (=h.ba 4) (=h.bb 5) (=h.bc 6)
-;;     (=h.ca 1) (=h.cb 2) (=h.cc 3) (=h.ca 4) (=h.cb 5) (=h.cc 6)
-;;     (=h.da 1) (=h.db 2) (=h.dc 3) (=h.da 4) (=h.db 5) (=h.dc 6)
-;;     (=h.aa 1) (=h.ab 2) (=h.ac 3) (=h.ba 4) (=h.bb 5) (=h.bc 6)
-;;     (=h.ca 1) (=h.cb 2) (=h.cc 3) (=h.ca 4) (=h.cb 5) (=h.cc 6)
-;;     (=h.da 1) (=h.db 2) (=h.dc 3) (=h.da 4) (=h.db 5) (=h.dc 6)
-;;     (list (list h.aa h.ab h.ac h.ba h.bb h.bc)
-;;           (list h.aa h.ab h.ac h.ba h.bb h.bc)
-;;           (list h.ca h.cb h.cc h.ca h.cb h.cc)
-;;           (list h.da h.db h.dc h.da h.db h.dc)
-;;           (list h.aa h.ab h.ac h.ba h.bb h.bc)
-;;           (list h.ca h.cb h.cc h.ca h.cb h.cc)
-;;           (list h.da h.db h.dc h.da h.db h.dc)
-;;           (list h.da h.ab h.ac h.ba h.bb h.bc))))
+;; (def bm-sym-lex-lex-lex () (with (a 1 b 2 c 3) (+ a b c)))
+;; (def bm-sym-lex-lit-lex () (with (a 1 c 3) (+ a 2 c)))
+
+;; (def bm-hash-fill ()
+;;   (with (h {} v1 1 v2 2 v3 3 v4 4 v5 5 v6 6)
+;;     (= h.aa v1) (= h.ab v2) (= h.ac v3) (= h.ba v4) (= h.bb v5) (= h.bc v6)
+;;     (= h.ca v1) (= h.cb v2) (= h.cc v3) (= h.ca v4) (= h.cb v5) (= h.cc v6)
+;;     (= h.da v1) (= h.db v2) (= h.dc v3) (= h.da v4) (= h.db v5) (= h.dc v6)
+;;     (= h.aa v1) (= h.ab v2) (= h.ac v3) (= h.ba v4) (= h.bb v5) (= h.bc v6)
+;;     (= h.ca v1) (= h.cb v2) (= h.cc v3) (= h.ca v4) (= h.cb v5) (= h.cc v6)
+;;     (= h.da v1) (= h.db v2) (= h.dc v3) (= h.da v4) (= h.db v5) (= h.dc v6)))
 
 (def rbs (name)
   (let summary nil
@@ -186,7 +181,10 @@
     ;; (push (bm "cond with OR       "   bm-cond-lex-lit-lit             10  100000) summary)
     ;; (push (bm "optimise DO forms "   bm-faster-do             10  10000) summary)
     ;; (push (bm "length of string "   bm-len-str              10  40000) summary)
-    (push (bm "length of pair "     bm-len-pair             10  10000) summary)
+    ;; (push (bm "length of pair "     bm-len-pair                10  10000) summary)
+    ;; (push (bm "sig opt 1"           bm-sym-lex-lex-lex         10 100000) summary)
+    ;; (push (bm "sig opt 2"           bm-sym-lex-lit-lex         10 100000) summary)
+    ;; (push (bm "hashing"             bm-hash-fill               10 5000) summary)
     ;; (push (bm "length of hash "     bm-len-hash             10  15000) summary)
     ;; (push (bm "length of uncountable "     bm-len-fn        10  50000) summary)
     ;; (push (bm "cond               "   bm-cond-3             10   50000) summary)

data/lib/nydp.rb

@@ -62,6 +62,7 @@ module Nydp
       puts "^D to exit" unless silent
       return if options[:exit]
       Nydp::Runner.new(VM.new(ns), ns, reader, $stdout, "<stdin>").run
+      # Nydp::Invocation.whazzup
     end
   end
 

data/lib/nydp/cond.rb

@@ -147,32 +147,31 @@ module Nydp
 
   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)
+      falsity = Nydp::NIL.is?(@condition.value vm.current_context)
+      vm.push_arg(falsity ? @when_false : @when_true)
     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)
+      falsity = Nydp::NIL.is?(@condition.value vm.current_context)
+      vm.push_arg(falsity ? @when_false : (@when_true.value vm.current_context))
     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
+      if Nydp::NIL.is?(@condition.value vm.current_context)
         vm.push_arg @when_false
+      else
+        @when_true.execute vm
       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.instructions.push (Nydp::NIL.is?(@condition.value) ? @when_false : @when_true)
       vm.contexts.push vm.current_context
     end
   end

data/lib/nydp/function_invocation.rb

@@ -3,10 +3,19 @@ module Nydp
   end
 
   module Invocation
+    @@sig_counts = Hash.new { |h,k| h[k] = 0}
+
+    # def self.sig name ; @@sig_counts[name] += 1 ; end
+
+    # def self.whazzup
+    #   puts @@sig_counts.to_a.sort_by { |c| c[1] }.map { |c| "#{c[1]}\t#{c[0]}"}
+    # end
+
     class Base
       include Helper
-      def initialize source_expression
+      def initialize source_expression, sig=nil
         @source_expression = source_expression
+        @sig = sig
       end
 
       def handle e, f, invoker, *args
@@ -33,6 +42,7 @@ module Nydp
 
     class Invocation_1 < Invocation::Base
       def execute vm
+#        Invocation.sig @sig
         f = vm.args.pop
         f.invoke_1 vm
       rescue StandardError => e
@@ -42,6 +52,7 @@ module Nydp
 
     class Invocation_2 < Invocation::Base
       def execute vm
+#        Invocation.sig @sig
         arg = vm.args.pop
         f = vm.args.pop
         f.invoke_2 vm, arg
@@ -52,6 +63,7 @@ module Nydp
 
     class Invocation_3 < Invocation::Base
       def execute vm
+#        Invocation.sig @sig
         arg_1 = vm.args.pop
         arg_0 = vm.args.pop
         f   = vm.args.pop
@@ -63,6 +75,7 @@ module Nydp
 
     class Invocation_4 < Invocation::Base
       def execute vm
+        # Invocation.sig @sig
         arg_2 = vm.args.pop
         arg_1 = vm.args.pop
         arg_0 = vm.args.pop
@@ -80,6 +93,7 @@ module Nydp
       end
 
       def execute vm
+#        Invocation.sig @sig
         args = vm.pop_args @arg_count
         args.car.invoke vm, args.cdr
       rescue StandardError => e
@@ -98,6 +112,7 @@ module Nydp
       end
 
       def execute vm
+#        Invocation.sig self.class.name
         @sym.value(vm.current_context).invoke_1 vm
       rescue StandardError => e
         handle e, @sym.value(vm.current_context), :invoke_1
@@ -112,6 +127,7 @@ module Nydp
       end
 
       def execute vm
+#        Invocation.sig self.class.name
         @sym.value.invoke_1 vm
       rescue StandardError => e
         handle e, @sym.value, :invoke_1
@@ -127,6 +143,7 @@ module Nydp
       end
 
       def execute vm
+#        Invocation.sig self.class.name
         fn = @lex0.value(vm.current_context)
         a0 = @lex1.value(vm.current_context)
         fn.invoke_2 vm, a0
@@ -144,11 +161,27 @@ module Nydp
       end
 
       def execute vm
-        fn = @sym.value
+#        Invocation.sig self.class.name
         a0 = @lex.value(vm.current_context)
-        fn.invoke_2 vm, a0
+        @sym.value.invoke_2 vm, a0
       rescue StandardError => e
-        handle e, fn, :invoke_2, a0
+        handle e, @sym.value, :invoke_2, a0
+      end
+    end
+
+    class Invocation_SYM_LIT < Invocation::Base
+      SIGS << self.name
+      def initialize expr, src
+        super src
+        @sym = expr.car
+        @lit = expr.cdr.car.expression
+      end
+
+      def execute vm
+#        Invocation.sig self.class.name
+        @sym.value.invoke_2 vm, @lit
+      rescue StandardError => e
+        handle e, @sym.value, :invoke_2, @lit
       end
     end
 
@@ -162,6 +195,7 @@ module Nydp
       end
 
       def execute vm
+#        Invocation.sig self.class.name
         fn = @lex_0.value(vm.current_context)
         a0 = @lex_1.value(vm.current_context)
         a1 = @lex_2.value(vm.current_context)
@@ -181,12 +215,71 @@ module Nydp
       end
 
       def execute vm
-        fn = @sym.value
+#        Invocation.sig self.class.name
         a0 = @lex_0.value(vm.current_context)
         a1 = @lex_1.value(vm.current_context)
-        fn.invoke_3 vm, a0, a1
+        @sym.value.invoke_3 vm, a0, a1
       rescue StandardError => e
-        handle e, fn, :invoke_3, a0, a1
+        handle e, @sym.value, :invoke_3, a0, a1
+      end
+    end
+
+    class Invocation_SYM_LEX_LEX_LEX < Invocation::Base
+      SIGS << self.name
+      def initialize expr, src
+        super src
+        @sym = expr.car
+        @lex_0 = expr.cdr.car
+        @lex_1 = expr.cdr.cdr.car
+        @lex_2 = expr.cdr.cdr.cdr.car
+      end
+
+      def execute vm
+#        Invocation.sig self.class.name
+        a0 = @lex_0.value(vm.current_context)
+        a1 = @lex_1.value(vm.current_context)
+        a2 = @lex_2.value(vm.current_context)
+        @sym.value.invoke_4 vm, a0, a1, a2
+      rescue StandardError => e
+        handle e, @sym.value, :invoke_4, a0, a1, a2
+      end
+    end
+
+    class Invocation_SYM_LEX_LIT_LEX < Invocation::Base
+      SIGS << self.name
+      def initialize expr, src
+        super src
+        @sym = expr.car
+        @lex_0 = expr.cdr.car
+        @lit_1 = expr.cdr.cdr.car.expression
+        @lex_2 = expr.cdr.cdr.cdr.car
+      end
+
+      def execute vm
+        # Invocation.sig self.class.name
+        a0 = @lex_0.value(vm.current_context)
+        a2 = @lex_2.value(vm.current_context)
+        @sym.value.invoke_4 vm, a0, @lit_1, a2
+      rescue StandardError => e
+        handle e, @sym.value, :invoke_4, a0, @lit_1, a2
+      end
+    end
+
+    class Invocation_SYM_LIT_LEX < Invocation::Base
+      SIGS << self.name
+      def initialize expr, src
+        super src
+        @sym = expr.car
+        @lit_0 = expr.cdr.car.expression
+        @lex_1 = expr.cdr.cdr.car
+      end
+
+      def execute vm
+#        Invocation.sig self.class.name
+        a1 = @lex_1.value(vm.current_context)
+        @sym.value.invoke_3 vm, @lit_0, a1
+      rescue StandardError => e
+        handle e, @sym.value, :invoke_3, @lit_0, a1
       end
     end
   end
@@ -194,7 +287,6 @@ module Nydp
   class FunctionInvocation
     extend Helper
     attr_accessor :function_instruction, :argument_instructions
-    @@put = nil
 
     def self.build expression, bindings
       compiled   = Compiler.compile_each(expression, bindings)
@@ -202,6 +294,8 @@ module Nydp
 
       cname  = "Invocation_#{invocation_sig}"
 
+      # puts expression.inspect if cname == "Invocation_SYM_LEX_LIT_LEX"
+
       exists = Invocation::SIGS.include? "Nydp::Invocation::#{cname}"
       if exists
         return Nydp::Invocation.const_get(cname).new(compiled, expression)
@@ -219,14 +313,16 @@ module Nydp
                         else
                           Invocation::Invocation_N.new(expression.size, expression)
                         end
-      new invocation, compiled, expression
+      new invocation, compiled, expression, cname
     end
 
-    def initialize function_instruction, argument_instructions, source
+    def initialize function_instruction, argument_instructions, source, sig=nil
       @function_instruction, @argument_instructions, @source = function_instruction, argument_instructions, source
+      @sig = sig
     end
 
     def execute vm
+##      Invocation.sig @sig
       vm.instructions.push function_instruction
       vm.contexts    .push vm.current_context
       vm.instructions.push argument_instructions

data/lib/nydp/literal.rb

@@ -7,10 +7,6 @@ module Nydp
       @expression = expression
     end
 
-    def lisp_apply
-      expression
-    end
-
     def self.build expression, bindings
       new expression
     end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-15 00:00:00.000000000 Z
+date: 2017-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler