nydp 0.5.0 → 0.6.0

data/lib/nydp/symbol.rb

@@ -10,6 +10,7 @@ class Nydp::Symbol
   def initialize name
     name = name.to_s
     @name = name.to_sym
+    raise "cannot be symbol : #{name.inspect}" if @name == :nil || @name == :t
     @inspection = "|#{name.gsub(/\|/, '\|')}|" if untidy(name)
   end
 
@@ -20,19 +21,21 @@ class Nydp::Symbol
   end
 
   def value context=nil
-    raise Unbound.new("unbound symbol: #{self.inspect}") if @value == nil
     @value
   end
 
-  def self.special name
-    return Nydp::NIL if name == :nil
-    return Nydp::T   if name == :t
-    nil
+  def ruby_name
+    "ns_#{name.to_s._nydp_name_to_rb_name}"
+  end
+
+  def compile_to_ruby indent, src, opts=nil
+    "#{indent}ns.#{ruby_name}"
   end
 
-  def self.mk name, ns
-    name = name.to_s.to_sym
-    ns[name] ||= new(name)
+  def self.special name
+    return nil  if name == :nil
+    return true if name == :t
+    nil
   end
 
   def self.find name, ns ; ns[name.to_sym] ;  end
@@ -47,7 +50,11 @@ class Nydp::Symbol
   def <             other ; self.name < other.name   ; end
   def <=>           other ; self.name <=> other.name ; end
   def assign value, _=nil ; @value = value           ; end
-  def execute          vm ; vm.push_arg self.value   ; end
+
+  def ns_assign ns, value
+    value.is_named(@name) if value.respond_to?(:is_named)
+    ns.send(:"#{ruby_name}=", value)
+  end
 
   def == other
     other.is_a?(Nydp::Symbol) && (self.name == other.name)
@@ -55,20 +62,3 @@ class Nydp::Symbol
 
   alias eql? ==
 end
-
-class Nydp::FrozenSymbol < Nydp::Symbol
-  @@frozen = { }
-
-  def self.mk name
-    name = name.to_s.to_sym
-    @@frozen[name] ||= new(name)
-  end
-
-  def value _=nil
-    raise Unbound.new("frozen symbol: #{self.inspect}")
-  end
-
-  def assign v, _=nil
-    raise "can't assign to frozen: #{self.inspect}"
-  end
-end

data/lib/nydp/symbol_lookup.rb

@@ -11,7 +11,7 @@ module Nydp
       bindings
     end
 
-    def self.build name, original_bindings
+    def self.build name, original_bindings, ns
       effective_bindings = skip_empty original_bindings
       depth    = 0
       while NIL != effective_bindings
@@ -24,7 +24,8 @@ module Nydp
           effective_bindings = skip_empty effective_bindings.cdr
         end
       end
-      name
+
+      Nydp::Symbol.new name.to_s.to_sym
     end
   end
 end

data/lib/nydp/tokeniser.rb

@@ -89,7 +89,7 @@ module Nydp
           @finished = true
           return nil
         elsif comment = s.scan(COMMENT)
-          tok = [:comment, comment.gsub(/^;;?\s*/, '').strip]
+          tok = [:comment, comment.gsub(/^;;?\s?/, '')]
         elsif open_str = s.scan(QUOTE)
           tok = [:string_open_delim, open_str]
         elsif open_sym = s.scan(PIPE)

data/lib/nydp/truth.rb

@@ -1,41 +1,6 @@
 require 'singleton'
 
 module Nydp
-  class Truth
-    include Singleton
-    def init_with *; Nydp::T     ; end
-    def to_s       ; 't'         ; end
-    def inspect    ; 't'         ; end
-    def assign  *_ ; self        ; end
-    def nydp_type  ; :truth      ; end
-    def to_ruby    ; true        ; end
-    def _nydp_get    a ; Nydp::T ; end
-    def _nydp_set a, v ; Nydp::T ; end
-  end
-
-  class Nil
-    include Singleton, Enumerable
-    def init_with * ; Nydp::NIL     ; end
-    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 to_s        ; ""            ; end
-    def + other     ; other         ; end
-    def copy        ; self          ; end
-    def assign *_   ; self          ; end
-    def inspect     ; "nil"         ; end
-    def nydp_type   ; :nil          ; end
-    def to_ruby     ; nil           ; end
-    def execute     vm ; vm.push_arg self ; end
-    def _nydp_get    a ; Nydp::NIL        ; end
-    def _nydp_set a, v ; Nydp::NIL        ; end
-    def each           ;                  ; end # nil behaves like an empty list
-    def &        other ; self             ; end
-    def |        other ; other            ; end
-  end
-
-  NIL = Nil.instance
-  T   = Truth.instance
+  NIL = nil
+  T   = true
 end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/nydp.rb

@@ -2,30 +2,19 @@ require 'date'
 require 'set'
 
 module Nydp
-  class << self
-    attr_accessor :logger # not used by this gem but very useful in your app
-  end
-
-  class Namespace < Hash
-  end
+  GENERATED_CLASS_PREFIX = "NydpGenerated"
 
-  # TODO: write VM #apply_function so we have fewer calls to VM.new
-  def self.apply_function ns, function_name, *args
-    vm       = VM.new(ns)
-    function = Symbol.mk(function_name.to_sym, ns).value
-    function.invoke vm, r2n(args)
-    vm.thread
-  rescue StandardError => e
-    friendly_args = args.map { |a| a.respond_to?(:_nydp_compact_inspect) ? a._nydp_compact_inspect : a }
-    raise Nydp::Error.new("Invoking #{function_name}\nwith args #{friendly_args.inspect}")
+  class << self
+    attr_accessor :logger # set this if you plan on using 'log
   end
 
-  def self.reader                          txt ; Nydp::StringReader.new txt                                 ; end
-  def self.eval_src      ns, src_txt, name=nil ; eval_with Nydp::Runner, ns, src_txt, name                  ; end
-  def self.eval_with runner, ns, src_txt, name ; runner.new(VM.new(ns), ns, reader(src_txt), nil, name).run ; end
-  def self.ms                           t1, t0 ; ((t1 - t0) * 1000).to_i                                    ; end
-  def self.new_tokeniser                reader ; Nydp::Tokeniser.new reader                                 ; end
-  def self.new_parser                       ns ; Nydp::Parser.new(ns)                                       ; end
+  def self.apply_function      ns, name, *args ; ns.apply name, *args                                 ; end
+  def self.reader                    name, txt ; Nydp::StringReader.new name, txt                     ; end
+  def self.eval_src      ns, src_txt, name=nil ; eval_with Nydp::Runner, ns, src_txt, name            ; end
+  def self.eval_with runner, ns, src_txt, name ; runner.new(ns, reader(name, src_txt), nil, name).run ; end
+  def self.ms                           t1, t0 ; ((t1 - t0) * 1000).to_i                              ; end
+  def self.new_tokeniser                reader ; Nydp::Tokeniser.new reader                           ; end
+  def self.new_parser                          ; Nydp::Parser.new                                     ; end
 
   def self.indent_message indent, msg
     msg.split(/\n/).map { |line| "#{indent}#{line}" }.join("\n")
@@ -39,7 +28,7 @@ module Nydp
       puts "\n#{indent}Caused by:"
       handle_run_error e.cause, "#{indent}    "
     else
-      e.backtrace.each do |b|
+      Nydp.enhance_backtrace(e.backtrace).each do |b|
         puts "#{indent}#{b}"
       end
     end
@@ -54,34 +43,34 @@ module Nydp
   end
 
   def self.repl options={ }
-    toplevel do
-      launch_time      = Time.now
-      silent           = options.delete :silent
-      ns               = options.delete :ns
-      last_script_time = Time.now
-      puts "welcome to nydp #{options.inspect}" unless silent
-      reader = Nydp::ReadlineReader.new $stdin, "nydp > "
-      ns   ||= build_nydp do |script|
-        this_script_time = Time.now
-        puts "script #{script} time #{ms this_script_time, last_script_time}ms" if options[:verbose]
-        last_script_time = this_script_time
+    launch_time      = Time.now
+    silent           = options.delete :silent
+    ns               = options.delete :ns
+    last_script_time = Time.now
+    puts "welcome to nydp #{options.inspect}" unless silent
+    reader = Nydp::ReadlineReader.new $stdin, "nydp > "
+    ns   ||= build_nydp do |script|
+      this_script_time = Time.now
+      puts "script #{script} time #{ms this_script_time, last_script_time}ms" if options[:verbose]
+      last_script_time = this_script_time
+    end
+    load_time = Time.now
+    puts "nydp v#{Nydp::VERSION} repl ready in #{ms(load_time, launch_time)}ms" unless silent
+    puts "^D to exit" unless silent
+    while !options[:exit]
+      toplevel do
+        Nydp::Runner.new(ns, reader, $stdout, "<stdin>").run
+        options[:exit] = true
       end
-      load_time = Time.now
-      puts "nydp v#{Nydp::VERSION} repl ready in #{ms(load_time, launch_time)}ms" unless silent
-      puts "^D to exit" unless silent
-      return if options[:exit]
-      Nydp::Runner.new(VM.new(ns), ns, reader, $stdout, "<stdin>").run
-      # Nydp::Invocation.whazzup
     end
+    # Nydp::Invocation.whazzup
   end
 
   def self.tests *options
     toplevel do
-      verbose = options.include?(:verbose) ? "t" : "nil"
+      verbose = options.include?(:verbose) ? true : nil
       puts "welcome to nydp : running tests"
-      reader = Nydp::StringReader.new "(run-all-tests #{verbose})"
-      ns     = build_nydp
-      Nydp::Runner.new(VM.new(ns), ns, reader, nil, "<test-runner>").run
+      build_nydp.apply :"run-all-tests", verbose
     end
   end
 end
@@ -105,4 +94,4 @@ require "nydp/string_token"
 require "nydp/tokeniser"
 require "nydp/parser"
 require "nydp/compiler"
-require "nydp/vm"
+require "nydp/namespace"

data/nydp.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "rake", "~> 12"
+  spec.add_development_dependency "irb"
+  spec.add_development_dependency "rake", "~> 13"
   spec.add_development_dependency 'rspec' #, '~> 3.1'
 end

data/spec/date_spec.rb

@@ -2,33 +2,29 @@ require 'spec_helper'
 
 describe Nydp::Date do
 
-  let(:ns) { { }               }
-  let(:vm) { Nydp::VM.new(ns)  }
 
   it "converts ruby Date to Nydp::Date" do
     rd = Date.parse "2015-06-08"
     nd = Nydp.r2n rd
 
-    expect(nd).        to be_a Nydp::Date
+    expect(nd).        to be_a ::Date
     expect(nd.to_s).   to eq "2015-06-08"
-    expect(nd.inspect).to eq "#<Date: 2015-06-08 ((2457182j,0s,0n),+0s,2299161j)>"
+    expect(nd._nydp_inspect).to eq "#<Date: 2015-06-08 ((2457182j,0s,0n),+0s,2299161j)>"
     expect(nd.to_ruby).to eq Date.parse("2015-06-08")
   end
 
   it "creates a new date" do
     df = Nydp::Builtin::Date.instance
-    df.invoke_4 vm, 2015, 11, 18
-    nd = vm.args.pop
-    expect(nd).to be_a Nydp::Date
-    expect(nd.ruby_date).to eq Date.parse("2015-11-18")
+    nd = df.call 2015, 11, 18
+    expect(nd).to be_a ::Date
+    expect(nd).to eq Date.parse("2015-11-18")
   end
 
   it "returns today" do
     df = Nydp::Builtin::Date.instance
-    df.invoke_1 vm
-    nd = vm.args.pop
-    expect(nd).to be_a Nydp::Date
-    expect(nd.ruby_date).to eq Date.today
+    nd = df.call
+    expect(nd).to be_a ::Date
+    expect(nd).to eq Date.today
   end
 
   it "returns date components" do
@@ -47,10 +43,9 @@ describe Nydp::Date do
     it "works with builtin minus" do
       minus = Nydp::Builtin::Minus.instance
 
-      minus.invoke vm, pair_list([d1, d0])
-      diff = vm.args.pop
+      diff = minus.call d1, d0
 
-      expect(d0).to be_a Nydp::Date
+      expect(d0).to be_a ::Date
       expect(diff).to eq 6
     end
 
@@ -58,25 +53,25 @@ describe Nydp::Date do
       it "works with builtin greater-than when true" do
         f = Nydp::Builtin::GreaterThan.instance
 
-        f.invoke vm, pair_list([d1, d0])
+        a = f.call d1, d0
 
-        expect(vm.args.pop).to eq d0
+        expect(a).to eq d0
       end
 
       it "compares with nil" do
         f = Nydp::Builtin::GreaterThan.instance
 
-        f.invoke vm, pair_list([d1, Nydp::NIL])
+        a = f.call d1, nil
 
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq Nydp::NIL
       end
 
       it "works with builtin greater-than when false" do
         f = Nydp::Builtin::GreaterThan.instance
 
-        f.invoke vm, pair_list([d0, d1])
+        a = f.call d0, d1
 
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq Nydp::NIL
       end
     end
 
@@ -84,37 +79,36 @@ describe Nydp::Date do
       it "works with builtin less-than when true" do
         f = Nydp::Builtin::LessThan.instance
 
-        f.invoke vm, pair_list([d0, d1])
+        a = f.call d0, d1
 
-        expect(vm.args.pop).to eq d1
+        expect(a).to eq d1
       end
 
       it "works with builtin less-than when false" do
         f = Nydp::Builtin::LessThan.instance
 
-        f.invoke vm, pair_list([d1, d0])
+        a = f.call d1, d0
 
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq Nydp::NIL
       end
 
       it "compares with nil" do
         f = Nydp::Builtin::LessThan.instance
 
-        f.invoke vm, pair_list([d1, Nydp::NIL])
+        a = f.call d1, nil
 
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq Nydp::NIL
       end
     end
 
     it "works with builtin plus" do
       plus = Nydp::Builtin::Plus.instance
 
-      plus.invoke vm, pair_list([d0, 5])
-      sum = vm.args.pop
+      sum = plus.call d0, 5
 
-      expect(d0) .to be_a Nydp::Date
-      expect(sum).to be_a Nydp::Date
-      expect(sum.ruby_date).to eq(Date.today + 5)
+      expect(d0) .to be_a ::Date
+      expect(sum).to be_a ::Date
+      expect(sum).to eq(Date.today + 5)
     end
   end
 

data/spec/embedded_spec.rb

@@ -1,27 +1,27 @@
 require 'spec_helper'
 
 describe Nydp::Parser do
-  let(:aa)               { Nydp::Symbol.mk :aa,                   ns }
-  let(:a)                { Nydp::Symbol.mk :a,                    ns }
-  let(:b)                { Nydp::Symbol.mk :b,                    ns }
-  let(:c)                { Nydp::Symbol.mk :c,                    ns }
-  let(:d)                { Nydp::Symbol.mk :d,                    ns }
-  let(:zz)               { Nydp::Symbol.mk :zz,                   ns }
-  let(:foo)              { Nydp::Symbol.mk :foo,                  ns }
-  let(:bar)              { Nydp::Symbol.mk :bar,                  ns }
-  let(:zab)              { Nydp::Symbol.mk :zab,                  ns }
-  let(:quote)            { Nydp::Symbol.mk :quote,                ns }
-  let(:quasiquote)       { Nydp::Symbol.mk :quasiquote,           ns }
-  let(:unquote)          { Nydp::Symbol.mk :unquote,              ns }
-  let(:unquote_splicing) { Nydp::Symbol.mk :"unquote-splicing",   ns }
-  let(:comment)          { Nydp::Symbol.mk :comment,              ns }
-  let(:dotsyn)           { Nydp::Symbol.mk :"dot-syntax",         ns }
-  let(:cocosyn)          { Nydp::Symbol.mk :"colon-colon-syntax", ns }
-  let(:colosyn)          { Nydp::Symbol.mk :"colon-syntax",       ns }
+  let(:aa)               { :aa                    }
+  let(:a)                { :a                     }
+  let(:b)                { :b                     }
+  let(:c)                { :c                     }
+  let(:d)                { :d                     }
+  let(:zz)               { :zz                    }
+  let(:foo)              { :foo                   }
+  let(:bar)              { :bar                   }
+  let(:zab)              { :zab                   }
+  let(:quote)            { :quote                 }
+  let(:quasiquote)       { :quasiquote            }
+  let(:unquote)          { :unquote               }
+  let(:unquote_splicing) { :"unquote-splicing"    }
+  let(:comment)          { :comment               }
+  let(:dotsyn)           { :"dot-syntax"          }
+  let(:cocosyn)          { :"colon-colon-syntax"  }
+  let(:colosyn)          { :"colon-syntax"        }
 
   def parse_string txt
-    reader = Nydp::StringReader.new txt
-    Nydp.new_parser(ns).embedded(Nydp.new_tokeniser(reader))
+    reader = Nydp::StringReader.new "test", txt
+    Nydp.new_parser.embedded(Nydp.new_tokeniser(reader))
   end
 
   it "should parse empty string" do
@@ -33,14 +33,14 @@ describe Nydp::Parser do
   it "should parse external text" do
     actual   = parse_string "a fluffy bunny!"
     expect(actual)        .to eq "a fluffy bunny!"
-    expect(actual.inspect).to eq '"a fluffy bunny!"'
+    expect(actual._nydp_inspect).to eq '"a fluffy bunny!"'
   end
 
   it "should parse a string delimited by eof" do
     expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('a fluffy bunny!','a fluffy bunny!')])
     actual   = parse_string "a fluffy bunny!"
     expect(actual)        .to eq "a fluffy bunny!"
-    expect(actual.inspect).to eq '"a fluffy bunny!"'
+    expect(actual._nydp_inspect).to eq '"a fluffy bunny!"'
   end
 
   it "should parse a string with embedded code, delimited by eof" do
@@ -104,6 +104,6 @@ describe Nydp::Parser do
 
   it "parses a string that looks like html with little bits of embedded code in it" do
     parsed = parse_string "<div id='item_~{id}'><label>~{data-label-1}</label> ~{data-content-1}</div>"
-    expect(parsed.inspect).to eq '(string-pieces "<div id=\'item_" (brace-list id) "\'><label>" (brace-list data-label-1) "</label> " (brace-list data-content-1) "</div>")'
+    expect(parsed._nydp_inspect).to eq '(string-pieces "<div id=\'item_" (brace-list id) "\'><label>" (brace-list data-label-1) "</label> " (brace-list data-content-1) "</div>")'
   end
 end

data/spec/error_spec.rb

@@ -1,40 +1,36 @@
 require 'spec_helper'
 
-describe Nydp::VM do
-  let(:ns) { { } }
-  let(:vm) { Nydp::VM.new(ns) }
+describe Nydp do
 
   def run txt
     Nydp.setup ns
-    Nydp::Runner.new(vm, ns, Nydp::StringReader.new(txt)).run
+    Nydp::Runner.new(ns, Nydp::StringReader.new("test", txt)).run
   end
 
   describe "unhandled_error" do
     it "raises a helpful error" do
       error = nil
       begin
-        run "dflkjdgjeirgjeoi"
+        run "(/ 10 0)"
       rescue StandardError => e
         error = e
       end
 
       expect(error).to be_a Nydp::Error
-      expect(error.message).to eq "failed to eval dflkjdgjeirgjeoi"
+      expect(error.message).to eq "failed to eval (/ 10 0) from src (/ 10 0)"
 
-      expect(error.cause).to be_a Nydp::Symbol::Unbound
-      expect(error.cause.message).to eq "unbound symbol: dflkjdgjeirgjeoi"
+      expect(error.cause).to be_a RuntimeError
+      expect(error.cause.message).to eq "Called builtin//
+with args
+  10
+  0"
 
-      expect(vm.unhandled_error).to eq nil
+      expect(error.cause.cause).to be_a ZeroDivisionError
+      expect(error.cause.cause.message).to eq "divided by 0"
     end
 
     it "recovers quickly from an error" do
-      begin
-        run "dflkjdgjeirgjeoi"
-      rescue
-      end
-
-      expect(vm.unhandled_error).to eq nil
-
+      run "dflkjdgjeirgjeoi"
       expect(run "(+ 2 3 4)").to eq 9
     end
   end

data/spec/foreign_hash_spec.rb

@@ -1,75 +1,61 @@
 require "spec_helper"
 
-describe Nydp::Hash do
-  let(:vm) { Nydp::VM.new(ns) }
+describe ::Hash do
 
   describe "foreign hashes" do
     let(:ahash) { Hash.new }
 
     describe "hash set" do
       it "returns a new Nydp hash" do
-        k    = Nydp::Symbol.mk "keysym", ns
+        k    = :keysym
         v    = "foobar"
-        args = pair_list [ahash, k, v]
-        Nydp::Builtin::HashSet.instance.invoke vm, args
+        a    = Nydp::Builtin::HashSet.instance.call ahash, k, v
 
         expect(ahash[:keysym]).      to eq "foobar"
         expect(ahash[:keysym].class).to eq String
         expect(ahash.keys).          to eq [:keysym]
 
-        expect(vm.args.pop).to eq v
+        expect(a).to eq v
       end
     end
 
     describe "hash get" do
       it "converts ruby value to nydp value" do
         ahash[:keysym] = "avalue"
-        k              = sym("keysym")
-        args           = [ ahash, k ]
 
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
+        a = Nydp::Builtin::HashGet.instance.call ahash, :keysym
 
-        expect(vm.args.pop).to eq "avalue"
+        expect(a).to eq "avalue"
       end
 
       it "converts ruby nil to nydp value" do
-        k              = sym("keysym")
-        args           = [ ahash, k ]
+        a = Nydp::Builtin::HashGet.instance.call ahash, :keysym
 
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq nil
       end
 
       it "converts ruby true to nydp value" do
         ahash[:keysym] = true
-        k              = sym("keysym")
-        args           = [ ahash, k ]
 
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
+        a = Nydp::Builtin::HashGet.instance.call ahash, :keysym
 
-        expect(vm.args.pop).to eq Nydp::T
+        expect(a).to eq true
       end
     end
 
     describe "key?" do
       it "returns t when key is present" do
         ahash[:simon] = 24
-        k             = sym("simon")
-        args          = [ ahash, k ]
 
-        Nydp::Builtin::HashKeyPresent.instance.invoke vm, pair_list(args)
+        a = Nydp::Builtin::HashKeyPresent.instance.call ahash, :simon
 
-        expect(vm.args.pop).to eq Nydp::T
+        expect(a).to eq true
       end
 
       it "returns nil when key is absent" do
-        k             = sym("simon")
-        args          = [ ahash, k ]
-
-        Nydp::Builtin::HashKeyPresent.instance.invoke vm, pair_list(args)
+        a = Nydp::Builtin::HashKeyPresent.instance.call ahash, :simon
 
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq nil
       end
     end
 
@@ -77,23 +63,22 @@ describe Nydp::Hash do
       it "returns a list of keys" do
         ahash[:k0] = 42
         ahash[:k1] = 84
-        args       = [ahash]
 
-        Nydp::Builtin::HashKeys.instance.invoke vm, pair_list(args)
+        a = Nydp::Builtin::HashKeys.instance.call ahash
 
-        expect(vm.args.pop).to eq pair_list [sym("k0"), sym("k1")]
+        expect(a).to eq pair_list [:k0, :k1]
       end
     end
 
     describe "hash-slice" do
       it "returns a new hash containing only the given keys from the old hash" do
-        ahash[:k0] = 42
-        ahash[:k1] = 84
-        args       = [ahash, pair_list([sym("k0"), sym("k1")])]
+        ahash[:k0] =  42
+        ahash[:k1] =  84
+        ahash[:k2] = 126
 
-        Nydp::Builtin::HashSlice.instance.invoke vm, pair_list(args)
+        a = Nydp::Builtin::HashSlice.instance.call ahash, pair_list([:k0, :k1])
 
-        expect(vm.args.pop).to eq({ k0: 42, k1: 84 })
+        expect(a).to eq({ k0: 42, k1: 84 })
       end
     end
   end