nydp 0.5.1 → 0.6.0

data/lib/nydp/core_ext.rb

@@ -1,57 +1,118 @@
 class Object
-  def _nydp_get     a ; raise "_nydp_get : not gettable: #{a.inspect} on #{self.class.name}" ; end
-  def _nydp_set  a, v ; raise "_nydp_get : not settable: #{a.inspect} on #{self.class.name}" ; end
-  def _nydp_keys      ; []   ; end
-  def _nydp_wrapper   ; self ; end
-  def lexical_reach n ; n    ; end
+  def _nydp_get     a ; raise "_nydp_get : not gettable: #{a._nydp_inspect} on #{self.class.name}" ; end
+  def _nydp_set  a, v ; raise "_nydp_get : not settable: #{a._nydp_inspect} on #{self.class.name}" ; end
+  def _nydp_keys      ; []      ; end
+  def _nydp_wrapper         ; self          ; end
+  def _nydp_inspect         ; inspect       ; end
+  def _nydp_to_s            ; to_s          ; end
+  def _nydp_compact_inspect ; _nydp_inspect ; end
+  def lexical_reach       n ; n             ; end
+  def to_ruby               ; self          ; end
+  def compile_to_ruby indent, srcs, opts=nil ; "#{indent}#{inspect}" ; end
 end
 
 class Method
   include Nydp::Converter
-  def invoke_1 vm             ; vm.push_arg call._nydp_wrapper                            ; end
-  def invoke_2 vm, a0         ; vm.push_arg call(n2r(a0))._nydp_wrapper                   ; end
-  def invoke_3 vm, a0, a1     ; vm.push_arg call(n2r(a0), n2r(a1))._nydp_wrapper          ; end
-  def invoke_4 vm, a0, a1, a2 ; vm.push_arg call(n2r(a0), n2r(a1), n2r(a2))._nydp_wrapper ; end
-  def invoke   vm, args       ; vm.push_arg call(*(args.map { |a| n2r a}))._nydp_wrapper  ; end
+  def _nydp_call *args ; (call *(rubify args))._nydp_wrapper ; end
 end
 
-class NilClass
-  def _nydp_wrapper ; Nydp::NIL ; end
+class Proc
+  alias _nydp_call call
 end
 
-class FalseClass
-  def _nydp_wrapper ; Nydp::NIL ; end
+class TrueClass
+  def _nydp_inspect   ; 't'    ; end
+  def assign       *_ ; self   ; end
+  def nydp_type       ; :truth ; end
+  def _nydp_get     a ; self   ; end
+  def _nydp_set  a, v ; self   ; end
+  def _nydp_to_s      ; "t"    ; end
+  def compile_to_ruby indent, srcs, opts=nil ; "#{indent}true" ; end
 end
 
-class TrueClass
-  def _nydp_wrapper ; Nydp::T ; end
+class CantCallNil < NoMethodError
+end
+
+class NilClass
+  def car            ; self               ; end
+  def cdr            ; self               ; end
+  def size           ; 0                  ; end
+  def is?      other ; self.equal? other  ; end
+  def isnt?    other ; !self.equal? other ; end
+  def +        other ; other              ; end
+  def copy           ; self               ; end
+  def assign      *_ ; self               ; end
+  def nydp_type      ; :nil               ; end
+  def _nydp_get    a ; self               ; end
+  def _nydp_set a, v ; self               ; end
+  def &        other ; self               ; end
+  def |        other ; other              ; end
+  def _nydp_call  *_ ; raise CantCallNil  ; end
+  def compile_to_ruby i, s, o=nil ; "#{i}nil"      ; end
+end
+
+class FalseClass
+  def _nydp_wrapper ; nil ; end
 end
 
 class ::Symbol
-  def _nydp_wrapper ; Nydp::FrozenSymbol.mk(self) ; end
+  def _nydp_inspect
+    _ins = to_s
+    _nydp_untidy?(_ins) ? "|#{_ins.gsub(/\|/, '\|')}|" : _ins
+  end
+
+  def nydp_type  ; :symbol ; end
+  # def execute vm ; self    ; end
+
+  alias :inspect_before_nydp :inspect
+  def inspect
+    if self == :"#="
+      ':"#="'
+    else
+      inspect_before_nydp
+    end
+  end
+
+  private
+
+  def _nydp_untidy? s
+    (s == "") || (s == nil) || (s =~ /[\s\|,\(\)"]/)
+  end
 end
 
 class ::Date
-  def _nydp_wrapper ; Nydp::Date.new self ; end
+  def _nydp_get key ; _nydp_date.lookup key, self           ; end
+  def _nydp_date    ; @__nydp_date ||= Nydp::Date.new(self) ; end
+  def nydp_type     ; :date                                 ; end
 end
 
-class ::Array
-  def _nydp_wrapper ; Nydp::Pair.from_list map &:_nydp_wrapper ; end
+class ::Time
+  @@wl = Set.new %i{ year month day hour min sec }
+  def _nydp_time_get key ; send(key) if @@wl.include?(key) ; end
+  def _nydp_get      key ; _nydp_time_get(key.to_s.to_sym) ; end
+  def nydp_type          ; :time                           ; end
 end
 
-class ::Object
-  def to_ruby        ; self                       ; end
+class ::Array
+  def _nydp_wrapper ; Nydp::Pair.from_list map &:_nydp_wrapper   ; end
+  def _nydp_inspect ; "[" + map(&:_nydp_inspect).join(" ") + "]" ; end
 end
 
 class ::String
-  # def _nydp_wrapper  ; Nydp::StringAtom.new self  ; end
+  # _hex_ord only works for characters whose #ord is < 256, ie #bytes returns a single-element array
+  # this should allow for two-way conversion of names containing the characters in the regexp
+  # even though we don't use two-way conversion anywhere just yet
+  def _nydp_name_to_rb_name ; self.gsub(/[\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/) { |chr| "_#{chr._hex_ord}"}.to_sym ; end
   def as_method_name ; self.gsub(/-/, '_').to_sym ; end
   def nydp_type      ; :string                    ; end
+  def _hex_ord       ; ord.to_s(16).rjust(2, '0') ; end
 end
 
 class ::Hash
   include Nydp::Helper
-  def _nydp_get a    ; self[n2r a]           ; end
-  def _nydp_set a, v ; self[n2r a] = n2r(v)  ; end
-  def _nydp_keys     ; keys                  ; end
+  def _nydp_get a    ; self[a]._nydp_wrapper     ; end
+  def _nydp_set a, v ; self[a] = v               ; end
+  def _nydp_keys     ; keys                      ; end
+  def _nydp_inspect  ; "{" + map { |k,v| [k._nydp_inspect, v._nydp_inspect].join(" ")}.join(" ") + "}" ; end
+  def nydp_type      ; :hash                     ; end
 end

data/lib/nydp/date.rb

@@ -18,19 +18,18 @@ module Nydp
 
     def initialize ruby_date ; @ruby_date = ruby_date ; end
 
-    def to_date   ; ruby_date                                        ; end
-    def to_s      ; ruby_date.to_s                                   ; end
-    def to_ruby   ; ruby_date                                        ; end
-    def inspect   ; ruby_date.inspect                                ; end
-    def nydp_type ; :date                                            ; end
-    def >   other ; is_date?(other) && ruby_date > other.ruby_date   ; end
-    def <   other ; is_date?(other) && ruby_date < other.ruby_date   ; end
-    def ==  other ; is_date?(other) && ruby_date == other.ruby_date  ; end
-    def <=> other ; is_date?(other) && ruby_date <=> other.ruby_date ; end
-    def eql?    d ; self == d                                        ; end
-    def hash      ; ruby_date.hash                                   ; end
-    def is_date? other ; other.is_a? Nydp::Date                                                ; end
-    def -        other ; r2n(ruby_date - (is_date?(other) ? other.ruby_date : other))          ; end
+    def to_date        ; ruby_date                              ; end
+    def to_s           ; ruby_date.to_s                         ; end
+    def to_ruby        ; ruby_date                              ; end
+    def inspect        ; ruby_date.inspect                      ; end
+    def >        other ; is_date?(other) && ruby_date > other   ; end
+    def <        other ; is_date?(other) && ruby_date < other   ; end
+    def ==       other ; is_date?(other) && ruby_date == other  ; end
+    def <=>      other ; is_date?(other) && ruby_date <=> other ; end
+    def eql?         d ; self == d                              ; end
+    def hash           ; ruby_date.hash                         ; end
+    def is_date? other ; other.is_a? ::Date                     ; end
+    def -        other ; ruby_date - other                      ; end
     def +          int ; int.is_a?(Integer) ? r2n(ruby_date + int) : r2n(change(*int.to_ruby)) ; end
 
     @@pass_through = %i{ monday? tuesday? wednesday? thursday? friday? saturday? sunday? }
@@ -39,7 +38,8 @@ module Nydp
       last_year  next_year  beginning_of_year  end_of_year
       last_month next_month beginning_of_month end_of_month
       last_week  next_week  beginning_of_week  end_of_week
-      yesterday  tomorrow   age
+      yesterday  tomorrow   age                past?
+      future?
     } + @@pass_through
 
     def year               y, m, d, w ; y ; end
@@ -47,6 +47,9 @@ module Nydp
     def day                y, m, d, w ; d ; end
     def week_day           y, m, d, w ; w ; end
 
+    def future?                    *_ ; ruby_date > ::Date.today     ; end
+    def past?                      *_ ; ruby_date < ::Date.today     ; end
+
     def last_year          y, m, d, w ; ruby_date.prev_year          ; end
     def next_year          y, m, d, w ; ruby_date.next_year          ; end
     def beginning_of_year  y, m, d, w ; build(y, 1, 1)               ; end
@@ -76,11 +79,11 @@ module Nydp
       class_eval "def #{n} * ; ruby_date.#{n} ; end"
     end
 
-    def _nydp_keys                ; @@keys.to_a                                                              ; end
-    def dispatch  key, y, m, d, w ; self.send(key, y, m, d, w) if _nydp_keys.include?(key)                   ; end
-    def splat                date ; [date.year, date.month, date.day, date.wday]                             ; end
-    def lookup          key, date ; r2n(dispatch(key.to_s.gsub(/-/, '_').to_sym, *splat(date)))              ; end
-    def _nydp_get             key ; lookup key, ruby_date                                                    ; end
+    def _nydp_keys                ; @@keys.to_a                                                 ; end
+    def dispatch  key, y, m, d, w ; self.send(key, y, m, d, w) if _nydp_keys.include?(key)      ; end
+    def splat                date ; [date.year, date.month, date.day, date.wday]                ; end
+    def lookup          key, date ; r2n(dispatch(key.to_s.gsub(/-/, '_').to_sym, *splat(date))) ; end
+    def _nydp_get             key ; lookup key, ruby_date                                       ; end
     def change       amount, attr
       if    attr == :day   ; (ruby_date + amount)
       elsif attr == :week  ; (ruby_date + (7 * amount))

data/lib/nydp/error.rb

@@ -9,8 +9,7 @@ module Nydp
       @nydp_cause = nydp_cause
     end
 
-    def cause
-      @nydp_cause || super
-    end
+    def nydp_type ; :error               ; end
+    def cause     ; @nydp_cause || super ; end
   end
 end

data/lib/nydp/function_invocation.rb

@@ -3,32 +3,77 @@ 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 expr, source, sig=nil
         @expr, @source, @sig = expr, source, sig
       end
 
+      def compile_to_ruby indent, srcs, opts={}
+        ruby = if opts[:cando]
+                 compile_do_expr_to_ruby indent, srcs
+               end
+
+        ruby ||= normal_compile_to_ruby indent, srcs
+      end
+
+      def compile_do_expr_to_ruby indent, srcs
+        if @expr.car.is_a?(InterpretedFunction) && !@expr.cdr && @expr.car.can_do?
+          @expr.car.compile_do_expr_to_ruby indent, srcs
+        end
+      end
+
+      def normal_compile_to_ruby indent, srcs
+        ra = @expr.map { |e| e.compile_to_ruby "#{indent}  ", srcs}.to_a
+        fn_expr = @expr.first.to_s.inspect.gsub("\'", "\\\\'")
+        fn = ra.shift
+
+        src_expr = @expr.inspect.split(/\n/).join('\n')
+
+        if ra.empty?
+          "#{indent}  ##> #{src_expr}
+#{indent}  (begin ; #{fn}.
+#{indent}    ##> #{src_expr}
+#{indent}    _nydp_call()
+#{indent}   rescue CantCallNil => e
+#{indent}    (raise 'can\\'t call nil : #{fn_expr}')
+#{indent}   end)"
+        else
+          "#{indent}  ##> #{src_expr}
+#{indent}  (begin ; #{fn}.
+#{indent}    ##> #{src_expr}
+#{indent}    _nydp_call(#{ra.join(",\n")})
+#{indent}   rescue CantCallNil => e
+#{indent}    (raise 'can\\'t call nil : #{fn_expr}')
+#{indent}   end)"
+        end
+      end
+
+#       def compile_to_ruby indent, srcs
+#         ra = @expr.map { |e| e.compile_to_ruby "#{indent}  ", srcs}
+#         fn = ra.shift
+
+#         if ra.empty?
+#           "#{indent}#{fn}._nydp_callable(#{@expr.first.to_s.inspect})._nydp_call()"
+#         else
+#           "#{indent}#{fn}._nydp_callable(#{@expr.first.to_s.inspect})._nydp_call(
+# #{ra.join(",\n")}
+# #{indent})"
+#         end
+#       end
+
       def handle e, f, invoker, *args
         case e
         when Nydp::Error, InvocationFailed
           raise
         else
           if e.is_a?(NoMethodError) && !f.respond_to?(invoker)
-            raise InvocationFailed.new("#{f.inspect} is not a function: args were #{args.inspect} in #{source.inspect}")
+            raise InvocationFailed.new("#{f._nydp_inspect} is not a function: args were #{args._nydp_inspect} in #{source._nydp_inspect}")
           else
-            msg  = args.map { |a| "  #{a.inspect}"}.join("\n")
-            msg  =  "failed to execute invocation #{f.inspect}\n#{msg}"
-            msg +=  "\nsource was #{source.inspect}"
-            msg +=  "\nfunction name was #{source.car.inspect}"
+            msg  = args.map { |a| "  #{a._nydp_inspect}"}.join("\n")
+            msg  =  "failed to execute invocation #{f._nydp_inspect}\n#{msg}"
+            msg +=  "\nsource was #{source._nydp_inspect}"
+            msg +=  "\nfunction name was #{source.car._nydp_inspect}"
             raise InvocationFailed.new msg
           end
         end
@@ -39,253 +84,10 @@ module Nydp
         @expr.map { |x| x.lexical_reach n}.max
       end
 
-      def inspect ; @expr.map { |x| x.inspect }.join(' ') ; end
+      def inspect ; "(" + @expr.map { |x| x._nydp_inspect }.join(' ') + ")" ; end
       def source  ; @source       ; end
       def to_s    ; source.to_s   ; end
     end
-
-    class Invocation_1 < Invocation::Base
-      def execute vm
-#        Invocation.sig @sig
-        f = vm.args.pop
-        f.invoke_1 vm
-      rescue StandardError => e
-        handle e, f, :invoke_1
-      end
-    end
-
-    class Invocation_2 < Invocation::Base
-      def execute vm
-#        Invocation.sig @sig
-        arg = vm.args.pop
-        f = vm.args.pop
-        f.invoke_2 vm, arg
-      rescue StandardError => e
-        handle e, f, :invoke_2, arg
-      end
-    end
-
-    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
-        f.invoke_3 vm, arg_0, arg_1
-      rescue StandardError => e
-        handle e, f, :invoke_3, arg_0, arg_1
-      end
-    end
-
-    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
-        f   = vm.args.pop
-        f.invoke_4 vm, arg_0, arg_1, arg_2
-      rescue StandardError => e
-        handle e, f, :invoke_4, arg_0, arg_1, arg_2
-      end
-    end
-
-    class Invocation_N < Invocation::Base
-      def initialize arg_count, expr, source
-        super expr, source
-        @arg_count = arg_count
-      end
-
-      def execute vm
-#        Invocation.sig @sig
-        args = vm.pop_args @arg_count
-        args.car.invoke vm, args.cdr
-      rescue StandardError => e
-        handle e, args.car, :invoke, args.cdr
-      end
-    end
-
-    # TODO generate various Invocation_XXX classes on-demand instead of hand_coding them all up front
-    SIGS = Set.new
-
-    class Invocation_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-      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
-      end
-    end
-
-    class Invocation_SYM < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        @sym.value.invoke_1 vm
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_1
-      end
-    end
-
-    class Invocation_LEX_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @lex0 = expr.car
-        @lex1 = expr.cdr.car
-      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
-      rescue StandardError => e
-        handle e, fn, :invoke_2, a0
-      end
-    end
-
-    class Invocation_SYM_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lex = expr.cdr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        a0 = @lex.value(vm.current_context)
-        @sym.value.invoke_2 vm, a0
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_2, a0
-      end
-    end
-
-    class Invocation_SYM_LIT < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, 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
-
-    class Invocation_LEX_LEX_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @lex_0 = expr.car
-        @lex_1 = expr.cdr.car
-        @lex_2 = expr.cdr.cdr.car
-      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)
-        fn.invoke_3 vm, a0, a1
-      rescue StandardError => e
-        handle e, fn, :invoke_3, a0, a1
-      end
-    end
-
-    class Invocation_SYM_LEX_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lex_0 = expr.cdr.car
-        @lex_1 = expr.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)
-        @sym.value.invoke_3 vm, a0, a1
-      rescue StandardError => e
-        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 expr, 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 expr, 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 expr, 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
 
   class FunctionInvocation
@@ -293,35 +95,26 @@ module Nydp
     attr_accessor :function_instruction, :argument_instructions
 
     def lexical_reach n
-      function_instruction.car.lexical_reach(n)
+      function_instruction.lexical_reach(n)
     end
 
-    def self.build expression, bindings
-      compiled   = Compiler.compile_each(expression, bindings)
-      invocation_sig = compiled.map { |x| sig x }.join("_")
-
-      cname  = "Invocation_#{invocation_sig}"
+    def compile_to_ruby indent, srcs, opts=nil
+      ra = argument_instructions.map { |e| e.compile_to_ruby "#{indent}  ", srcs, cando: true }.to_a
+      if ra.length == 1
+        "#{indent}#{ra.shift}._nydp_call()"
+      else
+        "#{indent}#{ra.shift}._nydp_call(
+#{ra.join(",\n")}
+#{indent})"
+      end
+    end
 
-      # puts expression.inspect if cname == "Invocation_SYM_LEX_LIT_LEX"
+    @@seen = { }
 
-      exists = Invocation::SIGS.include? "Nydp::Invocation::#{cname}"
-      if exists
-        return Nydp::Invocation.const_get(cname).new(compiled, expression)
-      end
+    def self.build expression, bindings, ns
+      compiled   = Compiler.compile_each(expression, bindings, ns)
 
-      invocation = cons case expression.size
-                        when 1
-                          Invocation::Invocation_1.new(compiled, expression)
-                        when 2
-                          Invocation::Invocation_2.new(compiled, expression)
-                        when 3
-                          Invocation::Invocation_3.new(compiled, expression)
-                        when 4
-                          Invocation::Invocation_4.new(compiled, expression)
-                        else
-                          Invocation::Invocation_N.new(expression.size, compiled, expression)
-                        end
-      new invocation, compiled, expression, cname
+      Invocation::Base.new(compiled, expression)
     end
 
     def initialize function_instruction, argument_instructions, source, sig=nil
@@ -329,13 +122,7 @@ module Nydp
       @sig = sig
     end
 
-    def execute vm
-##      Invocation.sig @sig
-      vm.push_ctx_instructions function_instruction
-      vm.push_ctx_instructions argument_instructions
-    end
-
-    def inspect ; @function_instruction.inspect ; end
-    def to_s    ; @source.to_s                  ; end
+    def inspect ; @function_instruction._nydp_inspect ; end
+    def to_s    ; @source.to_s                        ; end
   end
 end