skeem 0.2.21 → 0.2.22

data/spec/skeem/interpreter_spec.rb

@@ -10,37 +10,39 @@ module Skeem
     include InterpreterSpec
     include DatumDSL
 
+    subject(:interpreter) { described_class.new }
+
     context 'Initialization:' do
       it 'could be initialized without an argument' do
-        expect { Interpreter.new }.not_to raise_error
+        expect { described_class.new }.not_to raise_error
       end
 
       it 'could be initialized with a block argument' do
-        expect { Interpreter.new(&:runtime) }.not_to raise_error
+        expect { described_class.new(&:runtime) }.not_to raise_error
       end
 
-      it 'should have a parser' do
-        expect(subject.parser).not_to be_nil
+      it 'has a parser' do
+        expect(interpreter.parser).not_to be_nil
       end
 
-      it 'should have a runtime object' do
-        expect(subject.runtime).to be_kind_of(Runtime)
+      it 'has a runtime object' do
+        expect(interpreter.runtime).to be_a(Runtime)
       end
 
-      it 'should come with built-in functions' do
-        expect(subject.runtime.environment).not_to be_empty
+      it 'comes with built-in functions' do
+        expect(interpreter.runtime.environment).not_to be_empty
       end
 
-      it 'should implement base bindings' do
-        expect(subject.fetch('number?')).to be_kind_of(Primitive::PrimitiveProcedure)
-        expect(subject.fetch('abs')).to be_kind_of(SkmLambda)
-        expect(subject.fetch('abs').formals.arity).to eq(1)
-        expect(subject.fetch('abs').formals.formals[0]).to eq('x')
+      it 'implements base bindings' do
+        expect(interpreter.fetch('number?')).to be_a(Primitive::PrimitiveProcedure)
+        expect(interpreter.fetch('abs')).to be_a(SkmLambda)
+        expect(interpreter.fetch('abs').formals.arity).to eq(1)
+        expect(interpreter.fetch('abs').formals.formals[0]).to eq('x')
       end
     end # context
 
     context 'Interpreting self-evaluating expressions' do
-      it 'should evaluate isolated booleans' do
+      it 'evaluates isolated booleans' do
         samples = [
           ['#f', false],
           ['#false', false],
@@ -48,12 +50,12 @@ module Skeem
           ['#true', true]
         ]
         compare_to_predicted(samples) do |result, predicted|
-          expect(result).to be_kind_of(SkmBoolean)
+          expect(result).to be_a(SkmBoolean)
           expect(result).to eq(predicted)
         end
       end
 
-      it 'should evaluate isolated integers' do
+      it 'evaluates isolated integers' do
         samples = [
           ['0', 0],
           ['3', 3],
@@ -62,13 +64,13 @@ module Skeem
           ['-12345', -12345]
         ]
         compare_to_predicted(samples) do |result, predicted|
-          expect(result).to be_kind_of(SkmInteger)
+          expect(result).to be_a(SkmInteger)
           expect(result).to eq(predicted)
         end
       end
 
       # rubocop: disable Style/ExponentialNotation
-      it 'should evaluate isolated real numbers' do
+      it 'evaluates isolated real numbers' do
         samples = [
           ['0.0', 0.0],
           ['3.14', 3.14],
@@ -77,27 +79,27 @@ module Skeem
           ['-123e-45', -123e-45]
         ]
         compare_to_predicted(samples) do |result, predicted|
-          expect(result).to be_kind_of(SkmReal)
+          expect(result).to be_a(SkmReal)
           expect(result).to eq(predicted)
         end
       end
       # rubocop: enable Style/ExponentialNotation
 
-      it 'should evaluate isolated strings' do
+      it 'evaluates isolated strings' do
         samples = [
           ['"Hello, world"', 'Hello, world']
         ]
         compare_to_predicted(samples) do |result, predicted|
-          expect(result).to be_kind_of(SkmString)
+          expect(result).to be_a(SkmString)
           expect(result).to eq(predicted)
         end
       end
 
-      it 'should evaluate vector of constants' do
+      it 'evaluates vector of constants' do
         require 'benchmark'
         source = '#(2018 10 20 "Sat")'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmVector)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmVector)
         predictions = [
           [SkmInteger, 2018],
           [SkmInteger, 10],
@@ -105,31 +107,31 @@ module Skeem
           [SkmString, 'Sat']
         ]
         predictions.each_with_index do |(type, value), index|
-          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to be_a(type)
           expect(result.members[index]).to eq(value)
         end
       end
     end # context
 
     context 'Built-in primitives' do
-      it 'should implement variable definition' do
-        subject.run('(define x 28)')
-        expect(subject.fetch('x')).to eq(28)
+      it 'implements variable definition' do
+        interpreter.run('(define x 28)')
+        expect(interpreter.fetch('x')).to eq(28)
       end
 
-      it 'should implement variable reference' do
+      it 'implements variable reference' do
         source = <<-SKEEM
   ; Example from R7RS section 4.1.1
   (define x 28)
   x
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         end_result = result.last
-        expect(end_result).to be_kind_of(SkmInteger)
+        expect(end_result).to be_a(SkmInteger)
         expect(end_result).to eq(28)
       end
 
-      it 'should implement the simple conditional form' do
+      it 'implements the simple conditional form' do
         checks = [
           ['(if (> 3 2) "yes")', 'yes'],
           ['(if (> 2 3) "yes")', SkmUndefined.instance]
@@ -137,7 +139,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the complete conditional form' do
+      it 'implements the complete conditional form' do
         checks = [
           ['(if (> 3 2) "yes" "no")', 'yes'],
           ['(if (> 2 3) "yes" "no")', 'no']
@@ -149,11 +151,11 @@ SKEEM
     (- 3 2)
     (+ 3 2))
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result).to eq(1)
       end
 
-      it 'should implement the cond form' do
+      it 'implements the cond form' do
         source = <<-SKEEM
   (define signum (lambda (x)
     (cond
@@ -162,7 +164,7 @@ SKEEM
       ((< x 0) -1)
     )))
 SKEEM
-        subject.run(source)
+        interpreter.run(source)
         checks = [
           ['(signum 3)', 1],
           ['(signum 0)', 0],
@@ -171,7 +173,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the cond form with arrows' do
+      it 'implements the cond form with arrows' do
         source = <<-SKEEM
   (define signum (lambda (x)
     (cond
@@ -180,7 +182,7 @@ SKEEM
       ((< x 0) => -1)
     )))
 SKEEM
-        subject.run(source)
+        interpreter.run(source)
         checks = [
           ['(signum 3)', 1],
           ['(signum 0)', 0],
@@ -189,7 +191,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the cond ... else form' do
+      it 'implements the cond ... else form' do
         source = <<-SKEEM
   (define signum (lambda (x)
     (cond
@@ -198,7 +200,7 @@ SKEEM
       (else -1)
     )))
 SKEEM
-        subject.run(source)
+        interpreter.run(source)
         checks = [
           ['(signum 3)', 1],
           ['(signum 0)', 0],
@@ -207,7 +209,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the truncate procedure' do
+      it 'implements the truncate procedure' do
         checks = [
           ['(truncate -4.3)', -4],
           ['(truncate 3.5)', 3]
@@ -215,7 +217,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the quotation of constant literals' do
+      it 'implements the quotation of constant literals' do
         checks = [
           ['(quote a)', 'a'],
           ['(quote 145932)', 145932],
@@ -229,25 +231,25 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the quotation of vectors' do
+      it 'implements the quotation of vectors' do
         source = '(quote #(a b c))'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmVector)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmVector)
         predictions = [
           [SkmIdentifier, 'a'],
           [SkmIdentifier, 'b'],
           [SkmIdentifier, 'c']
         ]
         predictions.each_with_index do |(type, value), index|
-          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to be_a(type)
           expect(result.members[index]).to eq(value)
         end
       end
 
-      it 'should implement the quotation of lists' do
+      it 'implements the quotation of lists' do
         source = '(quote (+ 1 2))'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmPair)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmPair)
         predictions = [
           [SkmIdentifier, '+'],
           [SkmInteger, 1],
@@ -255,25 +257,25 @@ SKEEM
         ]
         members = result.to_a
         predictions.each_with_index do |(type, value), index|
-          expect(members[index]).to be_kind_of(type)
+          expect(members[index]).to be_a(type)
           expect(members[index]).to eq(value)
         end
 
         source = "'()"
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmEmptyList)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmEmptyList)
         expect(result).to be_null
       end
 
-      it 'should implement the lambda function with one arg' do
+      it 'implements the lambda function with one arg' do
         source = <<-SKEEM
   ; Simplified 'abs' function implementation
   (define abs
     (lambda (x)
       (if (< x 0) (- x) x)))
 SKEEM
-        subject.run(source)
-        procedure = subject.fetch('abs')
+        interpreter.run(source)
+        procedure = interpreter.fetch('abs')
         expect(procedure.arity).to eq(1)
         checks = [
           ['(abs -3)', 3],
@@ -283,15 +285,15 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the lambda function with two args' do
+      it 'implements the lambda function with two args' do
         source = <<-SKEEM
   ; Simplified 'min' function implementation
   (define min
     (lambda (x y)
       (if (< x y) x y)))
 SKEEM
-        subject.run(source)
-        procedure = subject.fetch('min')
+        interpreter.run(source)
+        procedure = interpreter.fetch('min')
         expect(procedure.arity).to eq(2)
         checks = [
           ['(min 1 2)', 1],
@@ -301,7 +303,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement recursive functions' do
+      it 'implements recursive functions' do
         source = <<-SKEEM
   ; Example from R7RS section 4.1.5
   (define fact (lambda (n)
@@ -310,57 +312,57 @@ SKEEM
       (* n (fact (- n 1))))))
   (fact 10)
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last.value).to eq(3628800)
       end
 
-      it 'should accept calls to anonymous procedures' do
+      it 'accepts calls to anonymous procedures' do
         source = '((lambda (x) (+ x x)) 4)'
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result).to eq(8)
       end
 
-      it 'should support procedures with variable number of arguments' do
+      it 'supports procedures with variable number of arguments' do
         # Example from R7RS section 4.1.4
         source = '((lambda x x) 3 4 5 6)'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmPair)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmPair)
         expect(result.length).to eq(4)
       end
 
-      it 'should support procedures with dotted pair arguments' do
+      it 'supports procedures with dotted pair arguments' do
         # Example from R7RS section 4.1.4
         source = '((lambda (x y . z) z) 3 4 5 6)'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmPair)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmPair)
         expect(result.length).to eq(2)
         expect(result.first).to eq(5)
         expect(result.last).to eq(6)
       end
 
-      it 'should implement the compact define + lambda syntax' do
+      it 'implements the compact define + lambda syntax' do
           source = <<-SKEEM
   ; Alternative syntax to: (define f (lambda x (+ x 42)))
   (define (f x)
     (+ x 42))
   (f 23)
 SKEEM
-          result = subject.run(source)
+          result = interpreter.run(source)
           expect(result.last.value).to eq(65)
       end
 
-      it 'should implement the compact define + pair syntax' do
+      it 'implements the compact define + pair syntax' do
           source = <<-SKEEM
   ; Alternative syntax to: (define nlist (lambda args args))
   (define (nlist . args)
   args)
   (nlist 0 1 2 3 4)
 SKEEM
-          result = subject.run(source)
+          result = interpreter.run(source)
           expect(result.last.last.value).to eq(4)
       end
 
-      it 'should support the nested define construct' do
+      it 'supports the nested define construct' do
         source = <<-SKEEM
   (define (quadruple x)
     (define (double x) ; define a local procedure double
@@ -369,23 +371,23 @@ SKEEM
 
   (quadruple 5) ; => 20
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last.value).to eq(20)
       end
     end # context
 
     context 'Binding constructs:' do
-      it 'should implement local bindings' do
+      it 'implements local bindings' do
         source = <<-SKEEM
   (let ((x 2)
         (y 3))
     (* x y))
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result).to eq(6)
       end
 
-      it 'should implement precedence of local bindings' do
+      it 'implements precedence of local bindings' do
         source = <<-SKEEM
   (define x 23)
   (define y 42)
@@ -394,11 +396,11 @@ SKEEM
   (let ((y 43))
     (+ x y))
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last).to eq(66)
       end
 
-      it 'should support the nesting of local bindings' do
+      it 'supports the nesting of local bindings' do
         source = <<-SKEEM
   (let ((x 2) (y 3))
   (let ((x 7)
@@ -408,7 +410,7 @@ SKEEM
         expect_expr(source).to eq(35)
       end
 
-      it 'should support the nesting of a lambda in a let expression' do
+      it 'supports the nesting of a lambda in a let expression' do
         source = <<-SKEEM
   (define make-counter
     (lambda ()
@@ -425,11 +427,11 @@ SKEEM
   (c2)
   (c1)
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last).to eq(3)
       end
 
-      it 'should implement let* expression' do
+      it 'implements let* expression' do
         source = <<-SKEEM
   (let ((x 2) (y 3))
     (let* ((x 7)
@@ -441,28 +443,28 @@ SKEEM
     end # context
 
     context 'Sequencing constructs:' do
-      it 'should implement begin as a sequence of expressions' do
+      it 'implements begin as a sequence of expressions' do
         source = <<-SKEEM
   (define x 0)
   (and (= x 0)
     (begin (set! x 5)
       (+ x 1))) ; => 6
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last).to eq(6)
       end
 
-      it 'should implement begin as a sequence of expressions' do
+      it 'implements begin as a sequence of expressions' do
         source = <<-SKEEM
   (let ()
     (begin (define x 3) (define y 4))
     (+ x y))  ; => 7
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result).to eq(7)
       end
 
-      it 'should support begin as lambda body' do
+      it 'supports begin as lambda body' do
         source = <<-SKEEM
   (define kube (lambda (x)
     (begin
@@ -473,13 +475,13 @@ SKEEM
   (kube 3)
   (kube 4)
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last).to eq(64)
       end
     end # context
 
     context 'Quasiquotation:' do
-      it 'should implement the quasiquotation of constant literals' do
+      it 'implements the quasiquotation of constant literals' do
         checks = [
           ['(quasiquote a)', 'a'],
           ['(quasiquote 145932)', 145932],
@@ -493,44 +495,44 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the quasiquotation of vectors' do
+      it 'implements the quasiquotation of vectors' do
         source = '(quasiquote #(a b c))'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmVector)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmVector)
         predictions = [
           [SkmIdentifier, 'a'],
           [SkmIdentifier, 'b'],
           [SkmIdentifier, 'c']
         ]
         predictions.each_with_index do |(type, value), index|
-          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to be_a(type)
           expect(result.members[index]).to eq(value)
         end
       end
 
-      it 'should implement the unquote of vectors' do
+      it 'implements the unquote of vectors' do
         source = '`#( ,(+ 1 2) 4)'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmVector)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmVector)
         predictions = [
           [SkmInteger, 3],
           [SkmInteger, 4]
         ]
         predictions.each_with_index do |(type, value), index|
-          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to be_a(type)
           expect(result.members[index]).to eq(value)
         end
 
         source = '`#()'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmVector)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmVector)
         expect(result).to be_empty
 
         # Nested vectors
         source = '`#(a b #(,(+ 2 3) c) d)'
-        result = subject.run(source)
+        result = interpreter.run(source)
         # expected: #(a b #(5 c) d)
-        expect(result).to be_kind_of(SkmVector)
+        expect(result).to be_a(SkmVector)
         predictions = [
           [SkmIdentifier, 'a'],
           [SkmIdentifier, 'b'],
@@ -538,57 +540,57 @@ SKEEM
           [SkmIdentifier, 'd']
         ]
         predictions.each_with_index do |(type, value), index|
-          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to be_a(type)
           expect(result.members[index]).to eq(value)
         end
       end
 
-      it 'should implement the quasiquotation of lists' do
+      it 'implements the quasiquotation of lists' do
         source = '(quasiquote (+ 1 2))'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmPair)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmPair)
         predictions = [
           [SkmIdentifier, '+'],
           [SkmInteger, 1],
           [SkmInteger, 2]
         ]
         predictions.each do |(type, value)|
-          expect(result.car).to be_kind_of(type)
+          expect(result.car).to be_a(type)
           expect(result.car).to eq(value)
           result = result.cdr
         end
 
         source = '`()'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmEmptyList)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmEmptyList)
         expect(result).to be_null
       end
 
-      it 'should implement the unquote of lists' do
+      it 'implements the unquote of lists' do
         source = '`(list ,(+ 1 2) 4)'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmPair)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmPair)
         predictions = [
           [SkmIdentifier, 'list'],
           [SkmInteger, 3],
           [SkmInteger, 4]
         ]
         predictions.each do |(type, value)|
-          expect(result.car).to be_kind_of(type)
+          expect(result.car).to be_a(type)
           expect(result.car).to eq(value)
           result = result.cdr
         end
 
         source = '`()'
-        result = subject.run(source)
-        expect(result).to be_kind_of(SkmEmptyList)
+        result = interpreter.run(source)
+        expect(result).to be_a(SkmEmptyList)
         expect(result).to be_null
 
         # nested lists
         source = '`(a b (,(+ 2 3) c) d)'
-        result = subject.run(source)
+        result = interpreter.run(source)
         # expected: (a b (5 c) d)
-        expect(result).to be_kind_of(SkmPair)
+        expect(result).to be_a(SkmPair)
         predictions = [
           [SkmIdentifier, 'a'],
           [SkmIdentifier, 'b'],
@@ -596,7 +598,7 @@ SKEEM
           [SkmIdentifier, 'd']
         ]
         predictions.each do |(type, value)|
-          expect(result.car).to be_kind_of(type)
+          expect(result.car).to be_a(type)
           expect(result.car).to eq(value)
           result = result.cdr
         end
@@ -619,21 +621,21 @@ SKEEM
     end # context
 
     context 'Built-in primitive procedures' do
-      it 'should implement the division of numbers' do
-        result = subject.run('(/ 24 3)')
-        expect(result).to be_kind_of(SkmInteger)
+      it 'implements the division of numbers' do
+        result = interpreter.run('(/ 24 3)')
+        expect(result).to be_a(SkmInteger)
         expect(result).to eq(8)
       end
 
-      it 'should handle arithmetic expressions' do
-        result = subject.run('(+ (* 2 100) (* 1 10))')
-        expect(result).to be_kind_of(SkmInteger)
+      it 'handles arithmetic expressions' do
+        result = interpreter.run('(+ (* 2 100) (* 1 10))')
+        expect(result).to be_a(SkmInteger)
         expect(result).to eq(210)
       end
     end # context
 
     context 'Built-in standard procedures' do
-      it 'should implement the zero? predicate' do
+      it 'implements the zero? predicate' do
         checks = [
           ['(zero? 3.1)', false],
           ['(zero? -3.1)', false],
@@ -645,7 +647,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the positive? predicate' do
+      it 'implements the positive? predicate' do
         checks = [
           ['(positive? 3.1)', true],
           ['(positive? -3.1)', false],
@@ -657,7 +659,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the negative? predicate' do
+      it 'implements the negative? predicate' do
         checks = [
           ['(negative? 3.1)', false],
           ['(negative? -3.1)', true],
@@ -669,7 +671,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the even? predicate' do
+      it 'implements the even? predicate' do
         checks = [
           ['(even? 0)', true],
           ['(even? 1)', false],
@@ -679,7 +681,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the odd? predicate' do
+      it 'implements the odd? predicate' do
         checks = [
           ['(odd? 0)', false],
           ['(odd? 1)', true],
@@ -689,7 +691,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the abs function' do
+      it 'implements the abs function' do
         checks = [
           ['(abs 3.1)', 3.1],
           ['(abs -3.1)', 3.1],
@@ -701,7 +703,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the square function' do
+      it 'implements the square function' do
         checks = [
           ['(square 42)', 1764],
           ['(square 2.0)', 4.0],
@@ -710,7 +712,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the not procedure' do
+      it 'implements the not procedure' do
         checks = [
           ['(not #t)', false],
           ['(not 3)', false],
@@ -723,7 +725,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the list procedure' do
+      it 'implements the list procedure' do
         checks = [
           ['(list)', []],
           ['(list 1)', [1]],
@@ -735,7 +737,7 @@ SKEEM
         end
       end
 
-      it 'should implement the caar procedure' do
+      it 'implements the caar procedure' do
         checks = [
           ["(caar '((a)))", 'a'],
           ["(caar '((1 2) 3 4))", 1]
@@ -743,7 +745,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the cadr procedure' do
+      it 'implements the cadr procedure' do
         checks = [
           ["(cadr '(a b c))", 'b'],
           ["(cadr '((1 2) 3 4))", 3]
@@ -751,7 +753,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the cdar procedure' do
+      it 'implements the cdar procedure' do
         checks = [
           ["(cdar '((7 6 5 4 3 2 1) 8 9))", [6, 5, 4, 3, 2, 1]]
         ]
@@ -760,7 +762,7 @@ SKEEM
         end
       end
 
-      it 'should implement the cddr procedure' do
+      it 'implements the cddr procedure' do
         checks = [
           ["(cddr '(2 1))", []]
         ]
@@ -769,7 +771,7 @@ SKEEM
         end
       end
 
-      it 'should implement the symbol=? procedure' do
+      it 'implements the symbol=? procedure' do
         checks = [
           ["(symbol=? 'a 'a)", true],
           ["(symbol=? 'a (string->symbol \"a\"))", true],
@@ -778,7 +780,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the floor-quotient procedure' do
+      it 'implements the floor-quotient procedure' do
         checks = [
           ['(floor-quotient 5 2)', 2],
           ['(floor-quotient -5 2)', -3],
@@ -788,7 +790,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the floor-remainder (modulo) procedure' do
+      it 'implements the floor-remainder (modulo) procedure' do
         checks = [
           ['(floor-remainder 16 4)', 0],
           ['(floor-remainder 5 2)', 1],
@@ -804,7 +806,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the truncate-quotient procedure' do
+      it 'implements the truncate-quotient procedure' do
         checks = [
           ['(truncate-quotient 5 2)', 2],
           ['(truncate-quotient -5 2)', -2],
@@ -818,7 +820,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the truncate-remainder procedure' do
+      it 'implements the truncate-remainder procedure' do
         checks = [
           ['(truncate-remainder 5 2)', 1],
           ['(truncate-remainder -5 2)', -1],
@@ -832,7 +834,7 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-      it 'should implement the test-equal procedure' do
+      it 'implements the test-equal procedure' do
         checks = [
           ['(test-equal (cons 1 2) (cons 1 2))', true]
         ]
@@ -841,27 +843,27 @@ SKEEM
     end # context
 
     context 'Input/output:' do
-      it 'should implement the include expression' do
+      it 'implements the include expression' do
         initial_dir = Dir.pwd
         filedir = File.dirname(__FILE__)
         Dir.chdir(filedir)
         source = '(include "add4.skm")' # Path is assumed to be relative to pwd
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last).to eq(10)
         Dir.chdir(initial_dir)
       end
 
-      it 'should implement the newline procedure' do
+      it 'implements the newline procedure' do
         default_stdout = $stdout
         $stdout = StringIO.new
-        subject.run('(newline) (newline) (newline)')
+        interpreter.run('(newline) (newline) (newline)')
         expect($stdout.string).to match(/\n\n\n$/)
         $stdout = default_stdout
       end
     end # context
 
     context 'Second-order functions' do
-      it 'should implement lambda that calls second-order function' do
+      it 'implements lambda that calls second-order function' do
         source = <<-SKEEM
   (define twice
     (lambda (x)
@@ -875,11 +877,11 @@ SKEEM
       (compose f f)))
   ((repeat twice) 5)
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last).to eq(20)
       end
 
-      it 'should implement the composition of second-order functions' do
+      it 'implements the composition of second-order functions' do
         source = <<-SKEEM
   (define twice
     (lambda (x)
@@ -893,20 +895,20 @@ SKEEM
       (compose f f)))
   ((repeat (repeat twice)) 5)
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result.last).to eq(80)
       end
     end # context
 
     context 'Derived expressions' do
-      it 'should implement the do form' do
+      it 'implements the do form' do
         source = <<-SKEEM
           (do ((vec (make-vector 5))
                 (i 0 (+ i 1)))
               ((= i 5) vec)
             (vector-set! vec i i)) ; => #(0 1 2 3 4)
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result).to eq([0, 1, 2, 3, 4])
 
         source = <<-SKEEM
@@ -916,26 +918,26 @@ SKEEM
               (sum 0 (+ sum (car x))))
               ((null? x) sum))) ; => 25
 SKEEM
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result).to eq(25)
       end
     end # context
 
-    context 'Macro processing:' do
-      # it 'should parse macro expressions' do
-        # source = <<-SKEEM
-          # (define-syntax while
-            # (syntax-rules ()
-              # ((while condition body ...)
-               # (let loop ()
-                 # (if condition
-                     # (begin
-                       # body ...
-                       # (loop))
-                     # #f)))))
-# SKEEM
-        # ptree = subject.parse(source)
-      # end
-    end
+#     context 'Macro processing:' do
+#       # it 'parses macro expressions' do
+#         # source = <<-SKEEM
+#           # (define-syntax while
+#             # (syntax-rules ()
+#               # ((while condition body ...)
+#                # (let loop ()
+#                  # (if condition
+#                      # (begin
+#                        # body ...
+#                        # (loop))
+#                      # #f)))))
+# # SKEEM
+#         # ptree = interpreter.parse(source)
+#       # end
+#     end
   end # describe
 end # module