nydp 0.4.2 → 0.5.1

data/lib/nydp/builtin/type_of.rb

@@ -1,18 +1,21 @@
 class Nydp::Builtin::TypeOf
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    arg = args.car
-    typename = if arg.respond_to?(:nydp_type)
-                 arg.nydp_type.to_sym
-               elsif arg.is_a? Numeric
+  def builtin_invoke_1 vm, a0
+    typename = if a0.respond_to?(:nydp_type)
+                 a0.nydp_type.to_sym
+               elsif a0.is_a? Numeric
                  :number
                else
-                 "ruby/#{arg.class.name}".to_sym
+                 "ruby/#{a0.class.name}".to_sym
                end
 
     type = Nydp::Symbol.mk(typename, vm.ns)
 
     vm.push_arg(type || Nydp::NIL)
   end
+
+  def builtin_invoke vm, args
+    builtin_invoke_1 vm, args.car
+  end
 end

data/lib/nydp/closure.rb

@@ -4,9 +4,6 @@ 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

data/lib/nydp/cond.rb

@@ -6,6 +6,10 @@ module Nydp
       @when_true, @when_false = when_true, when_false
     end
 
+    def lexical_reach n
+      [@when_true.lexical_reach(n), @when_false.lexical_reach(n)].max
+    end
+
     def execute vm
       (Nydp::NIL.is?(vm.args.pop) ? @when_false : @when_true).execute vm
     end
@@ -13,6 +17,7 @@ module Nydp
     def inspect
       "when_true:#{@when_true.inspect}:when_false:#{@when_false.inspect}"
     end
+
     def to_s
       "#{@when_true.to_s} #{@when_false.to_s}"
     end
@@ -27,6 +32,10 @@ module Nydp
       @condition, @conditional = cond, cons(ExecuteConditionalInstruction.new(when_true, when_false))
     end
 
+    def lexical_reach n
+      [@condition.lexical_reach(n), @conditional.car.lexical_reach(n)].max
+    end
+
     def execute vm
       vm.push_ctx_instructions conditional
       condition.execute vm
@@ -35,6 +44,7 @@ module Nydp
     def inspect
       "cond:#{condition.inspect}:#{conditional.inspect}"
     end
+
     def to_s
       "(cond #{condition.to_s} #{conditional.to_s})"
     end
@@ -57,7 +67,7 @@ module Nydp
           new(cond, when_true, when_false)
         end
       else
-        raise "can't compile Cond: #{expr.inspect}"
+        raise "can't compile Cond: #{expressions.inspect}"
       end
     end
   end
@@ -70,6 +80,10 @@ module Nydp
       @condition, @when_true, @when_false = cond, when_true, when_false
     end
 
+    def lexical_reach n
+      [@condition.lexical_reach(n), @when_true.lexical_reach(n), @when_false.lexical_reach(n)].max
+    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
@@ -80,6 +94,14 @@ module Nydp
       vm.push_ctx_instructions (truth ? @when_true : @when_false)
     end
 
+    def lexical_reach n
+      cr = @condition.lexical_reach(n)
+      ct = @when_true.car.lexical_reach(n)
+      cf = @when_false.car.lexical_reach(n)
+
+      [cr, ct, cf].max
+    end
+
     def self.build cond, when_true, when_false
       tsig       = sig(when_true)
       fsig       = sig(when_false)

data/lib/nydp/context_symbol.rb

@@ -25,12 +25,18 @@ module Nydp
                   end
 
       code = <<-KLASS
-        def initialize name
-          @name = name
+        def initialize name, lexical_depth
+          @name, @lexical_depth = name, lexical_depth
+        end
+
+        def lexical_reach n
+          @lexical_depth + n
         end
 
         def value ctx
           ctx#{getctx}.#{at_index} || Nydp::NIL
+        rescue
+          raise "failed looking up \#{@name.inspect} (\#{@name.class.name})"
         end
 
         def assign value, ctx
@@ -45,16 +51,18 @@ module Nydp
 
         def depth   ; #{depth}                               ; end
         def inspect ; to_s                                   ; end
-        def to_s    ; "[#{depth}##{binding_index}]\#{@name}" ; end
+        def to_s    ; "[#{depth}##{binding_index}#\#{@lexical_depth}]\#{@name}" ; end
       KLASS
 
       const_set name, Class.new(Nydp::ContextSymbol) {
-        eval code
+        eval code, binding, name.to_s, 0
       }
     end
 
-    def self.build depth, name, binding_index
-      const_get(:"ContextSymbol_#{depth}_#{binding_index}").new(name)
+    def self.build effective_depth, name, binding_index, lexical_depth
+      const_get(:"ContextSymbol_#{effective_depth}_#{binding_index}").new(name, lexical_depth)
+    rescue
+      raise "building ContextSymbol #{[effective_depth, name, binding_index, lexical_depth].inspect}"
     end
   end
 end

data/lib/nydp/core.rb

@@ -25,9 +25,11 @@ module Nydp
     end
 
     def setup ns
-      Symbol.mk(:cons,  ns).assign(Nydp::Builtin::Cons.instance)
-      Symbol.mk(:car,   ns).assign(Nydp::Builtin::Car.instance)
-      Symbol.mk(:cdr,   ns).assign(Nydp::Builtin::Cdr.instance)
+      Symbol.mk(:cons         , ns).assign(Nydp::Builtin::RubyWrap::Cons.instance)
+      Symbol.mk(:car          , ns).assign(Nydp::Builtin::RubyWrap::Car.instance )
+      Symbol.mk(:cdr          , ns).assign(Nydp::Builtin::RubyWrap::Cdr.instance )
+      Symbol.mk(:log          , ns).assign(Nydp::Builtin::RubyWrap::Log.instance )
+
       Symbol.mk(:+,     ns).assign(Nydp::Builtin::Plus.instance)
       Symbol.mk(:-,     ns).assign(Nydp::Builtin::Minus.instance)
       Symbol.mk(:*,     ns).assign(Nydp::Builtin::Times.instance)
@@ -47,34 +49,40 @@ module Nydp
       Symbol.mk(:nil,   ns).assign Nydp::NIL
       Symbol.mk(:rand,  ns).assign Nydp::Builtin::Rand.instance
       Symbol.mk(:sort,  ns).assign Nydp::Builtin::Sort.instance
+      Symbol.mk(:abs,   ns).assign Nydp::Builtin::Abs.instance
       Symbol.mk(:sqrt,  ns).assign Nydp::Builtin::Sqrt.instance
       Symbol.mk(:t,     ns).assign Nydp::T
       Symbol.mk(:sym,   ns).assign Nydp::Builtin::Sym.instance
-      Symbol.mk(:ensuring,      ns).assign(Nydp::Builtin::Ensuring.instance)
-      Symbol.mk(:inspect,       ns).assign(Nydp::Builtin::Inspect.instance)
-      Symbol.mk(:comment,       ns).assign(Nydp::Builtin::Comment.instance)
-      Symbol.mk("handle-error"   , ns).assign(Nydp::Builtin::HandleError.instance)
-      Symbol.mk("parse-in-string", ns).assign(Nydp::Builtin::ParseInString.instance)
-      Symbol.mk("random-string"  , ns).assign(Nydp::Builtin::RandomString.instance)
-      Symbol.mk("to-string"      , ns).assign(Nydp::Builtin::ToString.instance)
-      Symbol.mk("string-length"  , ns).assign(Nydp::Builtin::StringLength.instance)
-      Symbol.mk("string-replace" , ns).assign(Nydp::Builtin::StringReplace.instance)
-      Symbol.mk("string-match"   , ns).assign(Nydp::Builtin::StringMatch.instance)
-      Symbol.mk("string-split"   , ns).assign(Nydp::Builtin::StringSplit.instance)
-      Symbol.mk("time"           , ns).assign(Nydp::Builtin::Time.instance)
-      Symbol.mk("thread-locals"  , ns).assign(Nydp::Builtin::ThreadLocals.instance)
-      Symbol.mk("type-of",      ns).assign(Nydp::Builtin::TypeOf.instance)
-      Symbol.mk(:"eq?",         ns).assign(Nydp::Builtin::IsEqual.instance)
-      Symbol.mk(:"cdr-set",     ns).assign(Nydp::Builtin::CdrSet.instance)
-      Symbol.mk(:"hash-get",    ns).assign(Nydp::Builtin::HashGet.instance)
-      Symbol.mk(:"hash-set",    ns).assign(Nydp::Builtin::HashSet.instance)
-      Symbol.mk(:"hash-keys",   ns).assign(Nydp::Builtin::HashKeys.instance)
-      Symbol.mk(:"hash-key?",   ns).assign(Nydp::Builtin::HashKeyPresent.instance)
-      Symbol.mk(:"hash-merge",  ns).assign(Nydp::Builtin::HashMerge.instance)
-      Symbol.mk(:"vm-info",     ns).assign Nydp::Builtin::VmInfo.instance
-      Symbol.mk(:"pre-compile" , ns).assign Nydp::Builtin::PreCompile.instance
-      Symbol.mk(:"script-run"  , ns).assign Nydp::Builtin::ScriptRun.instance
-      Symbol.mk(:"**"          , ns).assign Nydp::Builtin::MathPower.instance
+      Symbol.mk(:ensuring          , ns).assign(Nydp::Builtin::Ensuring.instance)
+      Symbol.mk(:inspect           , ns).assign(Nydp::Builtin::Inspect.instance)
+      Symbol.mk(:comment           , ns).assign(Nydp::Builtin::Comment.instance)
+      Symbol.mk("handle-error"     , ns).assign(Nydp::Builtin::HandleError.instance)
+      Symbol.mk("parse-in-string"  , ns).assign(Nydp::Builtin::ParseInString.instance)
+      Symbol.mk("random-string"    , ns).assign(Nydp::Builtin::RandomString.instance)
+      Symbol.mk("regexp"           , ns).assign(Nydp::Builtin::Regexp.instance)
+      Symbol.mk("to-string"        , ns).assign(Nydp::Builtin::ToString.instance)
+      Symbol.mk("to-integer"       , ns).assign(Nydp::Builtin::ToInteger.instance)
+      Symbol.mk("string-length"    , ns).assign(Nydp::Builtin::StringLength.instance)
+      Symbol.mk("string-replace"   , ns).assign(Nydp::Builtin::StringReplace.instance)
+      Symbol.mk("string-match"     , ns).assign(Nydp::Builtin::StringMatch.instance)
+      Symbol.mk("string-split"     , ns).assign(Nydp::Builtin::StringSplit.instance)
+      Symbol.mk("string/pad-left"  , ns).assign(Nydp::Builtin::StringPadLeft.instance)
+      Symbol.mk("string/pad-right" , ns).assign(Nydp::Builtin::StringPadRight.instance)
+      Symbol.mk("time"             , ns).assign(Nydp::Builtin::Time.instance)
+      Symbol.mk("thread-locals"    , ns).assign(Nydp::Builtin::ThreadLocals.instance)
+      Symbol.mk("type-of"          , ns).assign(Nydp::Builtin::TypeOf.instance)
+      Symbol.mk(:"eq?"             , ns).assign(Nydp::Builtin::IsEqual.instance)
+      Symbol.mk(:"cdr-set"         , ns).assign(Nydp::Builtin::CdrSet.instance)
+      Symbol.mk(:"hash-get"        , ns).assign(Nydp::Builtin::HashGet.instance)
+      Symbol.mk(:"hash-set"        , ns).assign(Nydp::Builtin::HashSet.instance)
+      Symbol.mk(:"hash-keys"       , ns).assign(Nydp::Builtin::HashKeys.instance)
+      Symbol.mk(:"hash-key?"       , ns).assign(Nydp::Builtin::HashKeyPresent.instance)
+      Symbol.mk(:"hash-merge"      , ns).assign(Nydp::Builtin::HashMerge.instance)
+      Symbol.mk(:"hash-slice"      , ns).assign(Nydp::Builtin::HashSlice.instance)
+      Symbol.mk(:"vm-info"         , ns).assign Nydp::Builtin::VmInfo.instance
+      Symbol.mk(:"pre-compile"     , ns).assign Nydp::Builtin::PreCompile.instance
+      Symbol.mk(:"script-run"      , ns).assign Nydp::Builtin::ScriptRun.instance
+      Symbol.mk(:"**"              , ns).assign Nydp::Builtin::MathPower.instance
       Symbol.mk(:"⌊"               , ns).assign Nydp::Builtin::MathFloor.instance
       Symbol.mk(:"math-floor"      , ns).assign Nydp::Builtin::MathFloor.instance
       Symbol.mk(:"⌈"               , ns).assign Nydp::Builtin::MathCeiling.instance

data/lib/nydp/core_ext.rb

@@ -1,8 +1,18 @@
 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 _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
+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
 end
 
 class NilClass
@@ -29,8 +39,14 @@ class ::Array
   def _nydp_wrapper ; Nydp::Pair.from_list map &:_nydp_wrapper ; end
 end
 
+class ::Object
+  def to_ruby        ; self                       ; end
+end
+
 class ::String
-  def _nydp_wrapper ; Nydp::StringAtom.new self ; end
+  # def _nydp_wrapper  ; Nydp::StringAtom.new self  ; end
+  def as_method_name ; self.gsub(/-/, '_').to_sym ; end
+  def nydp_type      ; :string                    ; end
 end
 
 class ::Hash

data/lib/nydp/date.rb

@@ -18,19 +18,20 @@ 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 +     int ; r2n(ruby_date + int)                             ; 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 is_date? other ; other.is_a? Nydp::Date                                                ; end
+    def -        other ; r2n(ruby_date - (is_date?(other) ? 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? }
     @@keys = Set.new %i{
@@ -38,7 +39,7 @@ 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
+      yesterday  tomorrow   age
     } + @@pass_through
 
     def year               y, m, d, w ; y ; end
@@ -46,15 +47,15 @@ module Nydp
     def day                y, m, d, w ; d ; end
     def week_day           y, m, d, w ; w ; end
 
-    def last_year          y, m, d, w ; build(y - 1, m, d)           ; 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
     def end_of_year        y, m, d, w ; build(y, 12, 31)             ; end
 
-    def last_month         y, m, d, w ; build(y, m - 1, d)           ; end
+    def last_month         y, m, d, w ; ruby_date.prev_month         ; end
     def next_month         y, m, d, w ; ruby_date.next_month         ; end
     def beginning_of_month y, m, d, w ; build(y, m, 1)               ; end
-    def end_of_month       y, m, d, w ; build(y, m, 31)              ; end
+    def end_of_month       y, m, d, w ; beginning_of_month(*splat(ruby_date.next_month)) - 1 ; end
 
     def last_week          y, m, d, w ; ruby_date - 7                ; end
     def next_week          y, m, d, w ; ruby_date + 7                ; end
@@ -64,21 +65,28 @@ module Nydp
     def yesterday          y, m, d, w ; ruby_date - 1                ; end
     def tomorrow           y, m, d, w ; ruby_date + 1                ; end
 
+    def age y,m,d,w # args not used
+      interval = (::Date.today - ruby_date) / 365.0
+      age_in_years = interval.to_i
+      extra_months = (12 * (interval - age_in_years)).to_i
+      { years: age_in_years, months: extra_months }
+    end
+
     @@pass_through.each do |n|
       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 _nydp_get key
-      key = key.to_s.gsub(/-/, '_').to_sym
-      y = ruby_date.year
-      m = ruby_date.month
-      d = ruby_date.day
-      w = ruby_date.wday
-
-      r2n(dispatch(key, y, m, d, w))
+    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))
+      elsif attr == :month ; (ruby_date >> amount)
+      elsif attr == :year  ; (ruby_date >> (12 * amount))
+      end
     end
   end
 end

data/lib/nydp/function_invocation.rb

@@ -13,9 +13,8 @@ module Nydp
 
     class Base
       include Helper
-      def initialize source_expression, sig=nil
-        @source_expression = source_expression
-        @sig = sig
+      def initialize expr, source, sig=nil
+        @expr, @source, @sig = expr, source, sig
       end
 
       def handle e, f, invoker, *args
@@ -24,7 +23,7 @@ module Nydp
           raise
         else
           if e.is_a?(NoMethodError) && !f.respond_to?(invoker)
-            raise InvocationFailed.new("#{f.inspect} is not a function: args were #{args.inspect}")
+            raise InvocationFailed.new("#{f.inspect} is not a function: args were #{args.inspect} in #{source.inspect}")
           else
             msg  = args.map { |a| "  #{a.inspect}"}.join("\n")
             msg  =  "failed to execute invocation #{f.inspect}\n#{msg}"
@@ -35,9 +34,14 @@ module Nydp
         end
       end
 
-      def inspect ; source.inspect     ; end
-      def source  ; @source_expression ; end
-      def to_s    ; source.to_s        ; end
+      # TODO: speed up compilation by writing custom #lexical_reach for sig-based subclasses (when you know which elements of #expr are lexical symbols)
+      def lexical_reach n
+        @expr.map { |x| x.lexical_reach n}.max
+      end
+
+      def inspect ; @expr.map { |x| x.inspect }.join(' ') ; end
+      def source  ; @source       ; end
+      def to_s    ; source.to_s   ; end
     end
 
     class Invocation_1 < Invocation::Base
@@ -87,8 +91,8 @@ module Nydp
     end
 
     class Invocation_N < Invocation::Base
-      def initialize arg_count, source_expression
-        super source_expression
+      def initialize arg_count, expr, source
+        super expr, source
         @arg_count = arg_count
       end
 
@@ -107,7 +111,7 @@ module Nydp
     class Invocation_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
       end
 
@@ -122,7 +126,7 @@ module Nydp
     class Invocation_SYM < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
       end
 
@@ -137,7 +141,7 @@ module Nydp
     class Invocation_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @lex0 = expr.car
         @lex1 = expr.cdr.car
       end
@@ -155,7 +159,7 @@ module Nydp
     class Invocation_SYM_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex = expr.cdr.car
       end
@@ -172,7 +176,7 @@ module Nydp
     class Invocation_SYM_LIT < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lit = expr.cdr.car.expression
       end
@@ -188,7 +192,7 @@ module Nydp
     class Invocation_LEX_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @lex_0 = expr.car
         @lex_1 = expr.cdr.car
         @lex_2 = expr.cdr.cdr.car
@@ -208,7 +212,7 @@ module Nydp
     class Invocation_SYM_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex_0 = expr.cdr.car
         @lex_1 = expr.cdr.cdr.car
@@ -227,7 +231,7 @@ module Nydp
     class Invocation_SYM_LEX_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex_0 = expr.cdr.car
         @lex_1 = expr.cdr.cdr.car
@@ -248,7 +252,7 @@ module Nydp
     class Invocation_SYM_LEX_LIT_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex_0 = expr.cdr.car
         @lit_1 = expr.cdr.cdr.car.expression
@@ -268,7 +272,7 @@ module Nydp
     class Invocation_SYM_LIT_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lit_0 = expr.cdr.car.expression
         @lex_1 = expr.cdr.cdr.car
@@ -288,6 +292,10 @@ module Nydp
     extend Helper
     attr_accessor :function_instruction, :argument_instructions
 
+    def lexical_reach n
+      function_instruction.car.lexical_reach(n)
+    end
+
     def self.build expression, bindings
       compiled   = Compiler.compile_each(expression, bindings)
       invocation_sig = compiled.map { |x| sig x }.join("_")
@@ -303,15 +311,15 @@ module Nydp
 
       invocation = cons case expression.size
                         when 1
-                          Invocation::Invocation_1.new(expression)
+                          Invocation::Invocation_1.new(compiled, expression)
                         when 2
-                          Invocation::Invocation_2.new(expression)
+                          Invocation::Invocation_2.new(compiled, expression)
                         when 3
-                          Invocation::Invocation_3.new(expression)
+                          Invocation::Invocation_3.new(compiled, expression)
                         when 4
-                          Invocation::Invocation_4.new(expression)
+                          Invocation::Invocation_4.new(compiled, expression)
                         else
-                          Invocation::Invocation_N.new(expression.size, expression)
+                          Invocation::Invocation_N.new(expression.size, compiled, expression)
                         end
       new invocation, compiled, expression, cname
     end
@@ -327,7 +335,7 @@ module Nydp
       vm.push_ctx_instructions argument_instructions
     end
 
-    def inspect ; @source.inspect ; end
-    def to_s    ; @source.to_s    ; end
+    def inspect ; @function_instruction.inspect ; end
+    def to_s    ; @source.to_s                  ; end
   end
 end