nydp 0.5.1 → 0.6.0

data/lib/nydp/compiler.rb

@@ -1,4 +1,5 @@
 require 'nydp/cond'
+require 'nydp/loop'
 require 'nydp/function_invocation'
 require 'nydp/interpreted_function'
 require 'nydp/literal'
@@ -7,48 +8,57 @@ module Nydp
   class Compiler
     extend Helper
 
-    def self.compile expression, bindings
-      compile_expr expression, bindings
+    def self.compile expression, bindings, ns
+      compile_expr expression, bindings, ns
     rescue StandardError => e
-      raise Nydp::Error.new "failed to compile expression:\n#{expression.inspect}"
+      raise Nydp::Error.new "failed to compile expression:\n#{expression._nydp_inspect}\n#{e.message}"
     end
 
-    def self.compile_expr expression, bindings
-      if expression.is_a? Nydp::Symbol
-        SymbolLookup.build expression, bindings
+    def self.compile_expr expression, bindings, ns
+      # if expression.is_a? Nydp::Symbol
+      if expression.is_a? ::Symbol
+        SymbolLookup.build expression, bindings, ns
       elsif literal? expression
-        Literal.build expression, bindings
+        Literal.build expression, bindings, ns
       elsif expression.is_a? Nydp::Pair
-        compile_pair expression, bindings
+        begin
+          compile_pair expression, bindings, ns
+        rescue => e
+          raise "failed to compile #{expression._nydp_inspect}"
+        end
+      else
+        raise Nydp::Error.new "failed to compile unrecognised expression:\n#{expression._nydp_inspect}\nwhich is a #{expression.class}"
       end
     end
 
     def self.maybe_cons a, b
-      Nydp::NIL.is?(a) ? b : cons(a, b)
+      (a == nil) ? b : cons(a, b)
     end
 
-    def self.compile_each expr, bindings
-      if Nydp::NIL.is?(expr)
+    def self.compile_each expr, bindings, ns
+      if expr == nil
         expr
       elsif pair?(expr)
-        maybe_cons compile(expr.car, bindings), compile_each(expr.cdr, bindings)
+        maybe_cons compile(expr.car, bindings, ns), compile_each(expr.cdr, bindings, ns)
       else
-        compile(expr, bindings)
+        compile(expr, bindings, ns)
       end
     end
 
-    def self.compile_pair expression, bindings
+    def self.compile_pair expression, bindings, ns
       key = expression.car
       if sym?(key, :cond)
-        Cond.build expression.cdr, bindings # todo: replace with function? (cond x (fn () iftrue) (fn () iffalse)) -->> performance issues, creating two closures for every cond invocation
+        Cond.build expression.cdr, bindings, ns # todo: replace with function? (cond x (fn () iftrue) (fn () iffalse)) -->> performance issues, creating two closures for every cond invocation
+      elsif sym?(key, :loop)
+        Loop.build expression.cdr, bindings, ns
       elsif sym?(key, :quote)
-        Literal.build expression.cadr, bindings
+        Literal.build expression.cadr, bindings, ns
       elsif sym?(key, :assign)
-        Assignment.build expression.cdr, bindings
+        Assignment.build expression.cdr, bindings, ns
       elsif sym?(key, :fn)
-        InterpretedFunction.build expression.cadr, expression.cddr, bindings
+        InterpretedFunction.build expression.cadr, expression.cddr, bindings, ns
       else
-        FunctionInvocation.build expression, bindings
+        FunctionInvocation.build expression, bindings, ns
       end
     end
   end

data/lib/nydp/cond.rb

@@ -1,73 +1,69 @@
 module Nydp
-  class ExecuteConditionalInstruction
-    extend Helper
-
-    def initialize when_true, when_false
-      @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
-
-    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
-  end
-
   class Cond
     extend Helper
     include Helper
     attr_reader :condition, :conditional
 
     def initialize cond, when_true, when_false
-      @condition, @conditional = cond, cons(ExecuteConditionalInstruction.new(when_true, when_false))
+      @condition, @when_true, @when_false = cond, when_true, when_false
     end
 
     def lexical_reach n
-      [@condition.lexical_reach(n), @conditional.car.lexical_reach(n)].max
+      [@condition.lexical_reach(n), @when_true.lexical_reach(n), @when_false.lexical_reach(n)].max
     end
 
     def execute vm
-      vm.push_ctx_instructions conditional
-      condition.execute vm
+      if (@condition.execute(vm))
+        @when_true.execute(vm)
+      else
+        @when_false.execute(vm)
+      end
+    end
+
+    def compile_to_ruby indent, srcs, opts=nil
+      if (!@when_false) || (@when_false.is_a?(Nydp::Literal) && !@when_false.expression)
+        "#{indent}##> #{inspect.split(/\n/).join('\n')}
+#{indent}if (#{@condition.compile_to_ruby "", srcs})
+#{@when_true.compile_to_ruby(indent + "  ", srcs, cando: true)}
+#{indent}end"
+      else
+        "#{indent}##> #{inspect.split(/\n/).join('\n')}
+#{indent}if (#{@condition.compile_to_ruby "", srcs})
+#{@when_true.compile_to_ruby(indent + "  ", srcs, cando: true)}
+#{indent}else
+#{@when_false.compile_to_ruby(indent + "  ", srcs, cando: true)}
+#{indent}end"
+      end
     end
 
     def inspect
-      "cond:#{condition.inspect}:#{conditional.inspect}"
+      "(cond #{condition._nydp_inspect} #{@when_true._nydp_inspect} #{@when_false._nydp_inspect})"
     end
 
     def to_s
-      "(cond #{condition.to_s} #{conditional.to_s})"
+      "(cond #{condition.to_s} #{@when_true.to_s} #{@when_false.to_s})"
     end
 
-    def self.build expressions, bindings
+    def self.build expressions, bindings, ns
       if expressions.is_a? Nydp::Pair
-        cond       = Compiler.compile expressions.car, bindings
-        when_true  = Compiler.compile expressions.cdr.car, bindings
-        when_false = Compiler.compile expressions.cdr.cdr.car, bindings
+        cond       = Compiler.compile expressions.car, bindings, ns
+        when_true  = Compiler.compile expressions.cdr.car, bindings, ns
+        when_false = Compiler.compile expressions.cdr.cdr.car, bindings, ns
         csig       = sig(cond)
-        # puts cond_sig
-        # TODO : handle literal nil explicitly (if x y) -> #when_false is literal nil, we can hardcode that
-        # todo : handle "OR" explicitly -> (if x x y) -> when #cond equals #when_true, hardcode this case
-        case csig
-        when "LEX"
-          Cond_LEX.build(cond, when_true, when_false)
-        when "SYM"
-          Cond_SYM.new(cond, cons(when_true), cons(when_false))
-        else
-          new(cond, when_true, when_false)
-        end
+        xsig       = "#{sig(cond)}_#{sig(when_true)}_#{sig(when_false)}"
+
+        # case csig
+        # when "LEX"
+        #   Cond_LEX.build(cond, when_true, when_false)
+        # when "SYM"
+        #   Cond_SYM.new(cond, when_true, when_false)
+        # else
+        #   new(cond, when_true, when_false)
+        # end
+
+        new(cond, when_true, when_false)
       else
-        raise "can't compile Cond: #{expressions.inspect}"
+        raise "can't compile Cond: #{expressions._nydp_inspect}"
       end
     end
   end
@@ -84,20 +80,26 @@ module Nydp
       [@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 inspect ; "cond:#{@condition._nydp_inspect}:#{@when_true._nydp_inspect}:#{@when_false._nydp_inspect}" ; end
     def to_s    ; "(cond #{@condition.to_s} #{@when_true.to_s} #{@when_false.to_s})" ; end
+    # def compile_to_ruby indent
+    #   "((#{@condition.compile_to_ruby "", srcs}) ? (#{@when_true.compile_to_ruby "", srcs}) : (#{@when_false.compile_to_ruby "", srcs}))"
+    # end
   end
 
   class Cond_LEX < CondBase
     def execute vm
-      truth = !Nydp::NIL.is?(@condition.value vm.current_context)
-      vm.push_ctx_instructions (truth ? @when_true : @when_false)
+      if @condition.value vm.current_context
+        @when_true.execute(vm)
+      else
+        @when_false.execute(vm)
+      end
     end
 
     def lexical_reach n
       cr = @condition.lexical_reach(n)
-      ct = @when_true.car.lexical_reach(n)
-      cf = @when_false.car.lexical_reach(n)
+      ct = @when_true.lexical_reach(n)
+      cf = @when_false.lexical_reach(n)
 
       [cr, ct, cf].max
     end
@@ -107,23 +109,27 @@ module Nydp
       fsig       = sig(when_false)
       cond_sig = "#{tsig}_#{fsig}"
 
-      # if (cond == when_true)
-      #   OR_LEX.build cond, when_false
-
       if (cond == when_true) && (fsig == "LIT")
-        OR_LEX_LIT.new cond, nil, when_false
+        OR_LEX_LIT.new cond, nil, when_false.expression
       elsif (cond == when_true) && (fsig == "LEX")
         OR_LEX_LEX.new cond, nil, when_false
+      elsif (cond == when_true)
+        OR_LEX_XXX.new cond, nil, when_false
       else
         case cond_sig
         when "LIT_LIT"
+          # puts "building Cond_LEX_LIT_LIT #{[cond, when_true.expression, when_false.expression]}"
           Nydp::Cond_LEX_LIT_LIT.new(cond, when_true.expression, when_false.expression)
         when "LEX_LIT"
           Nydp::Cond_LEX_LEX_LIT.new(cond, when_true, when_false.expression)
         when "CND_LIT"
           Nydp::Cond_LEX_CND_LIT.new(cond, when_true, when_false.expression)
+        when "NVB_LEX"
+          Nydp::Cond_LEX_NVB_LEX.new(cond, when_true, when_false)
+        when "NVB_LIT"
+          Nydp::Cond_LEX_NVB_LIT.new(cond, when_true, when_false.expression)
         else
-          Nydp::Cond_LEX.new(cond, cons(when_true), cons(when_false))
+          new(cond, when_true, when_false)
         end
       end
     end
@@ -131,67 +137,68 @@ module Nydp
 
   class OR_LEX_LIT < CondBase
     def execute vm
-      value = @condition.value vm.current_context
-      vm.push_arg(!Nydp::NIL.is?(value) ? value : @when_false)
+      @condition.value(vm.current_context) || @when_false
     end
   end
 
   class OR_LEX_LEX < CondBase
     def execute vm
-      value = @condition.value vm.current_context
-      vm.push_arg(!Nydp::NIL.is?(value) ? value : (@when_false.value vm.current_context))
+      @condition.value(vm.current_context) || (@when_false.value vm.current_context)
     end
   end
 
-  # class OR_LEX < CondBase
-  #   def execute vm
-  #     value = @condition.value vm.current_context
-  #     if !Nydp::NIL.is?(value)
-  #       vm.push_arg value
-  #     else
-  #       @when_false.execute vm
-  #     end
-  #   end
-
-  #   def self.build cond, when_false
-  #     case sig(when_false)
-  #     when "LIT"
-  #       OR_LEX_LIT.new(cond, nil, when_false)
-  #     when "LEX"
-  #       OR_LEX_LEX.new(cond, nil, when_false)
-  #     else
-  #       OR_LEX.new(cond, nil, when_false)
-  #     end
-  #   end
-  # end
+  class OR_LEX_XXX < CondBase
+    def execute vm
+      @condition.value(vm.current_context) || (@when_false.execute vm)
+    end
+  end
 
   class Cond_LEX_LIT_LIT < CondBase # (def no (arg) (cond arg nil t))
     def execute vm
-      falsity = Nydp::NIL.is?(@condition.value vm.current_context)
-      vm.push_arg(falsity ? @when_false : @when_true)
+      (@condition.value vm.current_context) ? @when_true : @when_false
     end
   end
 
   class Cond_LEX_LEX_LIT < CondBase
     def execute vm
-      falsity = Nydp::NIL.is?(@condition.value vm.current_context)
-      vm.push_arg(falsity ? @when_false : (@when_true.value vm.current_context))
+      (@condition.value vm.current_context) ? (@when_true.value vm.current_context) : @when_false
     end
   end
 
   class Cond_LEX_CND_LIT < CondBase
     def execute vm
-      if Nydp::NIL.is?(@condition.value vm.current_context)
-        vm.push_arg @when_false
+      if (@condition.value vm.current_context)
+        @when_true.execute vm
+      else
+        @when_false
+      end
+    end
+  end
+
+  class Cond_LEX_NVB_LEX < CondBase
+    def execute vm
+      if (@condition.value vm.current_context)
+        @when_true.execute vm
       else
+        @when_false.value(vm.current_context)
+      end
+    end
+  end
+
+  class Cond_LEX_NVB_LIT < CondBase
+    def execute vm
+      if (@condition.value vm.current_context)
         @when_true.execute vm
+      else
+        @when_false
       end
     end
   end
 
   class Cond_SYM < CondBase
     def execute vm
-      vm.push_ctx_instructions (Nydp::NIL.is?(@condition.value) ? @when_false : @when_true)
+      # puts "Cond_SYM"
+      (@condition.value) ? @when_true.execute(vm) : @when_false.execute(vm)
     end
   end
 end

data/lib/nydp/context_symbol.rb

@@ -24,6 +24,7 @@ module Nydp
                     "set_index(#{binding_index}, value)"
                   end
 
+      line = __LINE__ + 2
       code = <<-KLASS
         def initialize name, lexical_depth
           @name, @lexical_depth = name, lexical_depth
@@ -33,10 +34,14 @@ module Nydp
           @lexical_depth + n
         end
 
+        def compile_to_ruby indent, srcs, opts=nil
+          "\#{indent}_arg_\#{@name.to_s._nydp_name_to_rb_name}"
+        end
+
         def value ctx
-          ctx#{getctx}.#{at_index} || Nydp::NIL
+          ctx#{getctx}.#{at_index} || nil
         rescue
-          raise "failed looking up \#{@name.inspect} (\#{@name.class.name})"
+          raise "failed looking up \#{@name._nydp_inspect} (\#{@name.class.name}) : lookup expression was ctx#{getctx}.#{at_index}"
         end
 
         def assign value, ctx
@@ -45,24 +50,21 @@ module Nydp
           raise "problem in \#{self.class.name}#assign, name is \#{@name}, depth is \#{depth}, index is #{binding_index}"
         end
 
-        def execute vm
-          vm.push_arg value vm.current_context
-        end
-
         def depth   ; #{depth}                               ; end
         def inspect ; to_s                                   ; end
-        def to_s    ; "[#{depth}##{binding_index}#\#{@lexical_depth}]\#{@name}" ; end
+        # def to_s    ; "[#{depth}##{binding_index}#\#{@lexical_depth}]\#{@name}" ; end
+        def to_s    ; @name ; end
       KLASS
 
       const_set name, Class.new(Nydp::ContextSymbol) {
-        eval code, binding, name.to_s, 0
+        eval code, binding, "#{name.to_s} : #{__FILE__}", line
       }
     end
 
     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}"
+      raise "building ContextSymbol #{[effective_depth, name, binding_index, lexical_depth]._nydp_inspect}"
     end
   end
 end

data/lib/nydp/core.rb

@@ -2,11 +2,9 @@ require 'nydp/plugin'
 
 module Nydp
   class Core
-    def name ; "Nydp Core" ; end
+    include Nydp::PluginHelper
 
-    def relative_path name
-      File.join File.expand_path(File.dirname(__FILE__)), name
-    end
+    def name ; "Nydp Core" ; end
 
     def base_path
       relative_path "../lisp/"
@@ -17,81 +15,84 @@ module Nydp
     end
 
     def loadfiles
-      Dir.glob(relative_path '../lisp/core-*.nydp').sort
+      file_readers Dir.glob(relative_path '../lisp/core-*.nydp').sort
     end
 
     def testfiles
-      Dir.glob(relative_path '../lisp/tests/**/*.nydp')
+      file_readers Dir.glob(relative_path '../lisp/tests/**/*.nydp')
     end
 
     def setup ns
-      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)
-      Symbol.mk(:/,     ns).assign(Nydp::Builtin::Divide.instance)
-      Symbol.mk(:>,     ns).assign(Nydp::Builtin::GreaterThan.instance)
-      Symbol.mk(:<,     ns).assign(Nydp::Builtin::LessThan.instance)
-      Symbol.mk(:mod,   ns).assign(Nydp::Builtin::Modulo.instance)
-      Symbol.mk(:eval,  ns).assign(Nydp::Builtin::Eval.instance)
-      Symbol.mk(:false, ns).assign(false)
-      Symbol.mk(:hash,  ns).assign(Nydp::Builtin::Hash.instance)
-      Symbol.mk(:apply, ns).assign(Nydp::Builtin::Apply.instance)
-      Symbol.mk(:date,  ns).assign(Nydp::Builtin::Date.instance)
-      Symbol.mk(:error, ns).assign(Nydp::Builtin::Error.instance)
-      Symbol.mk(:parse, ns).assign(Nydp::Builtin::Parse.instance)
-      Symbol.mk(:p,     ns).assign(Nydp::Builtin::Puts.instance)
-      Symbol.mk(:PI,    ns).assign 3.1415
-      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("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
-      Symbol.mk(:"math-ceiling"    , ns).assign Nydp::Builtin::MathCeiling.instance
-      Symbol.mk(:"math-round"      , ns).assign Nydp::Builtin::MathRound.instance
-      Symbol.mk(:"⋂"               , ns).assign Nydp::Builtin::SetIntersection.instance
-      Symbol.mk(:"set-intersection", ns).assign Nydp::Builtin::SetIntersection.instance
-      Symbol.mk(:"⋃"               , ns).assign Nydp::Builtin::SetUnion.instance
-      Symbol.mk(:"set-union"       , ns).assign Nydp::Builtin::SetUnion.instance
+      ns.assign(:cons              , Nydp::Builtin::RubyWrap::Cons.instance          )
+      ns.assign(:car               , Nydp::Builtin::RubyWrap::Car.instance           )
+      ns.assign(:cdr               , Nydp::Builtin::RubyWrap::Cdr.instance           )
+      ns.assign(:log               , Nydp::Builtin::Log.instance                     )
+      ns.assign(:ln                , Nydp::Builtin::RubyWrap::Ln.instance            )
+      ns.assign(:mod               , Nydp::Builtin::RubyWrap::Modulo.instance        )
+      ns.assign(:sqrt              , Nydp::Builtin::RubyWrap::Sqrt.instance          )
+      ns.assign(:regexp            , Nydp::Builtin::RubyWrap::Regexp.instance        )
+      ns.assign("string/pad-left"  , Nydp::Builtin::RubyWrap::StringPadLeft.instance )
+      ns.assign("string/pad-right" , Nydp::Builtin::RubyWrap::StringPadRight.instance)
+      ns.assign("string/force-encoding", Nydp::Builtin::RubyWrap::StringForceEncoding.instance)
+      ns.assign("to-list"          , Nydp::Builtin::RubyWrap::ToList.instance        )
+      ns.assign(:+                 , Nydp::Builtin::Plus.instance                    )
+      ns.assign(:-                 , Nydp::Builtin::Minus.instance                   )
+      ns.assign(:*                 , Nydp::Builtin::Times.instance                   )
+      ns.assign(:/                 , Nydp::Builtin::Divide.instance                  )
+      ns.assign(:>                 , Nydp::Builtin::GreaterThan.instance             )
+      ns.assign(:<                 , Nydp::Builtin::LessThan.instance                )
+      ns.assign(:eval              , Nydp::Builtin::Eval.new(ns)                     )
+      ns.assign(:false             , false                                           )
+      ns.assign(:hash              , Nydp::Builtin::Hash.instance                    )
+      ns.assign(:apply             , Nydp::Builtin::Apply.instance                   )
+      ns.assign(:date              , Nydp::Builtin::Date.instance                    )
+      ns.assign(:error             , Nydp::Builtin::Error.instance                   )
+      ns.assign(:parse             , Nydp::Builtin::Parse.instance                   )
+      ns.assign(:p                 , Nydp::Builtin::Puts.instance                    )
+      ns.assign(:PI                , Math::PI                                        )
+      ns.assign(:"π"               , Math::PI                                        )
+      ns.assign(:rand              , Nydp::Builtin::Rand.instance                    )
+      ns.assign(:rng               , Nydp::Builtin::RNG.instance                     )
+      ns.assign(:sort              , Nydp::Builtin::Sort.instance                    )
+      ns.assign(:abs               , Nydp::Builtin::Abs.instance                     )
+      ns.assign(:sym               , Nydp::Builtin::Sym.instance                     )
+      ns.assign(:ensuring          , Nydp::Builtin::Ensuring.instance                )
+      ns.assign(:inspect           , Nydp::Builtin::Inspect.instance                 )
+      ns.assign(:comment           , Nydp::Builtin::Comment.instance                 )
+      ns.assign("handle-error"     , Nydp::Builtin::HandleError.instance             )
+      ns.assign("parse-in-string"  , Nydp::Builtin::ParseInString.instance           )
+      ns.assign("random-string"    , Nydp::Builtin::RandomString.instance            )
+      ns.assign("to-string"        , Nydp::Builtin::ToString.instance                )
+      ns.assign("to-integer"       , Nydp::Builtin::ToInteger.instance               )
+      ns.assign("string-length"    , Nydp::Builtin::StringLength.instance            )
+      ns.assign("string-replace"   , Nydp::Builtin::StringReplace.instance           )
+      ns.assign("string-match"     , Nydp::Builtin::StringMatch.instance             )
+      ns.assign("string-split"     , Nydp::Builtin::StringSplit.instance             )
+      ns.assign("time"             , Nydp::Builtin::Time.instance                    )
+      ns.assign("thread-locals"    , Nydp::Builtin::ThreadLocals.instance            )
+      ns.assign("type-of"          , Nydp::Builtin::TypeOf.instance                  )
+      ns.assign(:"eq?"             , Nydp::Builtin::IsEqual.instance                 )
+      ns.assign(:"cdr-set"         , Nydp::Builtin::CdrSet.instance                  )
+      ns.assign(:"hash-get"        , Nydp::Builtin::HashGet.instance                 )
+      ns.assign(:"hash-set"        , Nydp::Builtin::HashSet.instance                 )
+      ns.assign(:"hash-keys"       , Nydp::Builtin::HashKeys.instance                )
+      ns.assign(:"hash-key?"       , Nydp::Builtin::HashKeyPresent.instance          )
+      ns.assign(:"hash-merge"      , Nydp::Builtin::HashMerge.instance               )
+      ns.assign(:"hash-slice"      , Nydp::Builtin::HashSlice.instance               )
+      ns.assign(:"hash-to-array"   , Nydp::Builtin::HashToArray.instance             )
+      ns.assign(:"vm-info"         , Nydp::Builtin::VmInfo.instance                  )
+      ns.assign(:"pre-compile-new-expression", Nydp::Builtin::PreCompile.instance    )
+      ns.assign(:"script-run"      , Nydp::Builtin::ScriptRun.instance               )
+      ns.assign(:"**"              , Nydp::Builtin::MathPower.instance               )
+      ns.assign(:"⌊"               , Nydp::Builtin::MathFloor.instance               )
+      ns.assign(:"math-floor"      , Nydp::Builtin::MathFloor.instance               )
+      ns.assign(:"⌈"               , Nydp::Builtin::MathCeiling.instance             )
+      ns.assign(:"math-ceiling"    , Nydp::Builtin::MathCeiling.instance             )
+      ns.assign(:"math-round"      , Nydp::Builtin::MathRound.instance               )
+      ns.assign(:"⋂"               , Nydp::Builtin::SetIntersection.instance         )
+      ns.assign(:"set-intersection", Nydp::Builtin::SetIntersection.instance         )
+      ns.assign(:"⋃"               , Nydp::Builtin::SetUnion.instance                )
+      ns.assign(:"set-union"       , Nydp::Builtin::SetUnion.instance                )
     end
   end
 end