nydp 0.4.1 → 0.5.0

data/lib/nydp/core_ext.rb

@@ -0,0 +1,54 @@
+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
+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
+  def _nydp_wrapper ; Nydp::NIL ; end
+end
+
+class FalseClass
+  def _nydp_wrapper ; Nydp::NIL ; end
+end
+
+class TrueClass
+  def _nydp_wrapper ; Nydp::T ; end
+end
+
+class ::Symbol
+  def _nydp_wrapper ; Nydp::FrozenSymbol.mk(self) ; end
+end
+
+class ::Date
+  def _nydp_wrapper ; Nydp::Date.new self ; end
+end
+
+class ::Array
+  def _nydp_wrapper ; Nydp::Pair.from_list map &:_nydp_wrapper ; end
+end
+
+class ::String
+  # def _nydp_wrapper  ; Nydp::StringAtom.new self  ; end
+  def as_method_name ; self.gsub(/-/, '_').to_sym ; end
+  def nydp_type      ; :string                    ; end
+  def to_ruby        ; self                       ; 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
+end

data/lib/nydp/date.rb

@@ -16,23 +16,22 @@ module Nydp
       end
     end
 
-    def initialize ruby_date
-      @ruby_date = ruby_date
-    end
+    def initialize ruby_date ; @ruby_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            , nil) ; 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), nil) ; 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 +          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{
@@ -40,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
@@ -48,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
@@ -66,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 keys                     ; @@keys                                           ; end
-    def dispatch key, y, m, d, w ; self.send(key, y, m, d, w) if keys.include?(key) ; end
-
-    def [] 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), nil)
+    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

data/lib/nydp/hash.rb

@@ -1,10 +1,9 @@
 class Nydp::Hash < ::Hash
   include Nydp::Helper
 
-  def nydp_type ; :hash   ; end
-  def to_ruby
-    h = Hash.new
-    self.each { |k,v| h[n2r k] = n2r v }
-    h
-  end
+  def nydp_type      ; :hash                                             ; end
+  def to_ruby        ; each_with_object({}) {|(k,v),h| h[n2r k] = n2r v} ; end
+  def _nydp_get a    ; self[a]                                           ; end
+  def _nydp_set a, v ; self[a] = v                                       ; end
+  def _nydp_keys     ; keys                                              ; end
 end

data/lib/nydp/helper.rb

@@ -1,34 +1,50 @@
 module Nydp
-  R2NHELPERS = {
-    ::Symbol   => ->(obj, ns) { Nydp::Symbol.mk(obj, ns)                            },
-    Array      => ->(obj, ns) { Nydp::Pair.from_list obj.map { |o| Nydp.r2n o, ns } },
-    String     => ->(obj, ns) { Nydp::StringAtom.new obj.to_s                       },
-    NilClass   => ->(obj, ns) { Nydp::NIL                                           },
-    FalseClass => ->(obj, ns) { Nydp::NIL                                           },
-    TrueClass  => ->(obj, ns) { Nydp::T                                             },
-    ::Date     => ->(obj, ns) { Nydp::Date.new obj                                  },
-  }
-
-  def self.n2r nydp
-    nydp.respond_to?(:to_ruby) ? nydp.to_ruby : nydp
+  module AutoWrap
+    # include this and be sure to either override #_nydp_ok? or #_nydp_whitelist
+    # #_nydp_whitelist should return a list of accessor (zero-arg) methods which are safe for nydp to invoke
+    # #_nydp_procify should return a list of methods that can be exposed to script code.
+    #
+    # class Blub
+    #   _nydp_procs << :blubme
+    #   def blubme where, when
+    #     puts "blubme #{where}, #{when}"
+    #   end
+    # end
+    #
+    # in nydp, if blub is an instance of Blub:
+    #
+    # (blub.blubme "here" "now")
+    #
+    # prints
+    #
+    # blubme here, now
+    #
+    def _nydp_wrapper                 ; self                                     ; end
+    def _nydp_ok?              method ; _nydp_whitelist.include? method          ; end
+    def _nydp_procify?         method ; _nydp_procs.include? method              ; end # override to allow returning Method instances for given method name
+    def _nydp_get                 key ; _nydp_safe_send(key.to_s.as_method_name) ; end
+    def to_ruby                       ; self                                     ; end
+    def _nydp_safe_send meth, *args
+      return send meth, *args if _nydp_ok?(meth)
+      return method(meth)     if _nydp_procify?(meth)
+    end
   end
 
-  def self.r2n ruby_obj, ns
-    return ruby_obj._nydp_wrapper(ns) if ruby_obj.respond_to? :_nydp_wrapper
-
-    rklass = ruby_obj.class
-    R2NHELPERS.each do |hklass, proc|
-      if rklass <= hklass
-        return proc.call ruby_obj, ns
-      end
-    end
+  class Struct < ::Struct
+    include AutoWrap
+    def _nydp_whitelist ; members ; end
+    def _nydp_procs     ; []      ; end
+  end
 
-    ruby_obj
+  module Converter
+    def n2r         o ; o.respond_to?(:to_ruby) ? o.to_ruby : o ; end
+    def r2n o, ns=nil ; o._nydp_wrapper                         ; end
   end
 
+  extend Converter
+
   module Helper
-    def n2r obj     ; Nydp.n2r obj     ; end
-    def r2n obj, ns ; Nydp.r2n obj, ns ; end
+    include Converter
 
     def sig klass
       case klass
@@ -67,7 +83,7 @@ module Nydp
 
     def literal? expr
       case expr
-      when String, Float, Integer, Fixnum, Nydp::Symbol, Nydp::StringAtom, Nydp::Truth, Nydp::Nil
+      when String, Float, Integer, Integer, Nydp::Symbol, Nydp::Truth, Nydp::Nil
         true
       else
         false

data/lib/nydp/interpreted_function.rb

@@ -5,8 +5,8 @@ require 'nydp/closure'
 module Nydp
   class PopArg
     def self.execute vm ; vm.args.pop ; end
-    def self.to_s       ; ""         ; end
-    def self.inspect    ; "#pop_arg" ; end
+    def self.to_s       ; ""          ; end
+    def self.inspect    ; "#pop_arg"  ; end
   end
 
   class InterpretedFunction
@@ -16,42 +16,22 @@ module Nydp
 
     attr_accessor :arg_names, :body, :context_builder
 
-    def invoke_1 vm, parent_context
-      vm.push_instructions self.body, set_args_0(parent_context)
-    end
-
-    def invoke_2 vm, parent_context, arg
-      vm.push_instructions self.body, set_args_1(parent_context, arg)
-    end
-
-    def invoke_3 vm, parent_context, arg_0, arg_1
-      vm.push_instructions self.body, set_args_2(parent_context, arg_0, arg_1)
-    end
-
-    def invoke_4 vm, parent_context, arg_0, arg_1, arg_2
-      vm.push_instructions self.body, set_args_3(parent_context, arg_0, arg_1, arg_2)
-    end
-
-    def invoke vm, parent_context, arg_values
-      vm.push_instructions self.body, set_args(parent_context, arg_values)
-    end
-
-    def setup_context context, names, values
-      if pair? names
-        context.set names.car, values.car
-        setup_context context, names.cdr, values.cdr
-      elsif NIL != names
-        context.set names, values
-      end
+    def lexical_reach n
+      body.map { |b| b.lexical_reach(n - 1)  }.max
     end
 
     def self.build arg_list, body, bindings
       my_params = { }
       index_parameters arg_list, my_params
-      ifn = Nydp::InterpretedFunction.new
+      body = compile_body body, cons(my_params, bindings), []
+      reach = body.map { |b| b.lexical_reach(-1)  }.max
+
+      ifn_klass     = reach >= 0 ? InterpretedFunctionWithClosure : InterpretedFunctionWithoutClosure
+      ifn           = ifn_klass.new
       ifn.arg_names = arg_list
+      ifn.body      = body
+
       ifn.extend Nydp::LexicalContextBuilder.select arg_list
-      ifn.body = compile_body body, cons(my_params, bindings), []
       ifn
     end
 
@@ -62,6 +42,11 @@ module Nydp
       if Nydp::NIL.is? rest
         return Pair.from_list(instructions)
       else
+        # PopArg is necessary because each expression pushes an arg onto the arg stack.
+        # we only need to keep the arg pushed by the last expression in a function
+        # so we need the following line in order to remove unwanted args from the stack.
+        # Each expression at some executes vm.push_arg(thing)
+        # TODO find a more intelligent way to do this, eg change the meaning of vm or of push_arg in the expression vm.push_arg(thing)
         instructions << PopArg
         compile_body rest, bindings, instructions
       end
@@ -76,19 +61,62 @@ module Nydp
       end
     end
 
-    def execute vm
-      # TODO do not create a new Closure if this function does not refer to it
-      #      - including top-level function definitions
-      #      - and any other function that does not refer to any lexically-bound outer variable
-      #      - for example (fn (x) (* x x)) in (map λx(* x x) things) does not need a closure, because
-      #        the function does not refer to any lexical variable outside itself.
-      vm.push_arg Closure.new(self, vm.current_context)
-    end
-
     def nydp_type ; "fn" ; end
     def inspect   ; to_s ; end
     def to_s
       "(fn #{arg_names.inspect} #{body.map { |b| b.inspect}.join(' ')})"
     end
   end
+
+  class InterpretedFunctionWithClosure < InterpretedFunction
+    def invoke_1 vm, ctx
+      vm.push_instructions self.body, set_args_0(ctx)
+    end
+
+    def invoke_2 vm, ctx, arg
+      vm.push_instructions self.body, set_args_1(ctx, arg)
+    end
+
+    def invoke_3 vm, ctx, arg_0, arg_1
+      vm.push_instructions self.body, set_args_2(ctx, arg_0, arg_1)
+    end
+
+    def invoke_4 vm, ctx, arg_0, arg_1, arg_2
+      vm.push_instructions self.body, set_args_3(ctx, arg_0, arg_1, arg_2)
+    end
+
+    def invoke vm, ctx, arg_values
+      vm.push_instructions self.body, set_args(ctx, arg_values)
+    end
+
+    def execute vm
+      vm.push_arg Closure.new(self, vm.current_context)
+    end
+  end
+
+  class InterpretedFunctionWithoutClosure < InterpretedFunction
+    def invoke_1 vm
+      vm.push_instructions self.body, set_args_0(vm.current_context)
+    end
+
+    def invoke_2 vm, arg
+      vm.push_instructions self.body, set_args_1(vm.current_context, arg)
+    end
+
+    def invoke_3 vm, arg_0, arg_1
+      vm.push_instructions self.body, set_args_2(vm.current_context, arg_0, arg_1)
+    end
+
+    def invoke_4 vm, arg_0, arg_1, arg_2
+      vm.push_instructions self.body, set_args_3(vm.current_context, arg_0, arg_1, arg_2)
+    end
+
+    def invoke vm, arg_values
+      vm.push_instructions self.body, set_args(vm.current_context, arg_values)
+    end
+
+    def execute vm
+      vm.push_arg self
+    end
+  end
 end