skeem 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 482a0c8f936db1cc3099e133dda1d42d685d5e3c7fe244bf98f0062ad1470bc1
-  data.tar.gz: e950b89cf3a4bc7971a5263e96f7a8dbb670d926b03601d2c4116ccc03b613ec
+  metadata.gz: c08f4d71464aad98f53e99e6f66cd18e5961dbd1930353a560844b05d824e288
+  data.tar.gz: f38223cedadc6689670c1d4db901a25cf18caf5b2761519e866909575228b5d9
 SHA512:
-  metadata.gz: a8a6cde2cd049ccdf7ac4256b2313a462990f355790e6a23ab78febaa9f2377a39914f169c213e5ec1b2342e6bc611eeddae6f8f806ac3ecff713a356765403c
-  data.tar.gz: 6b9ea76b548deb643631515a755c431a30c915ad1db1dee609ceec1c03e17380d99f0fe33d1ab80a4eda4eec9de3a4acc55e03d6f8d4ebac800f650ad9695554
+  metadata.gz: 6618523bb5c1a4145b625ed5d264c1879f6980677df9c18e208f9a623652329cf952b4620a8c0c15c96cc38157e75f0590e9555535fa76b63a4361c866393bfb
+  data.tar.gz: 2b0ce438844db721e855dc9a805a66dcacac97240895d3be96e09e9634b8d80056e7dd4cdcb9e36c98896bb536f36ef0801ae830173a8b7ff0d1f032cfd3f18f

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.2.11] - 2019-06-16
+- Added procedures: `gcd`, `lcm`, `numerator`, `denominator`, `floor`, `ceiling`, `truncate`,
+  `round`.
+
+### Changed
+- File `interpreter_spec.rb`: Refactoring by DRYing code
+- File `primitive_builder_spec.rb`: Refactoring by DRYing code
+- File `base.skm` added implementation of  `truncate`
+- File `primitive_builder.rb` Implemented primitive procedures `gcd`, `lcm`, `numerator`, `denominator`, `floor`, `ceiling`, `round`.
+- File `README.md` Added mentions to new procedures.
+
 ## [0.2.10] - 2019-06-15
 - Skeem now supports rational numbers (fractions)
 - Added procedures: `max`, `min`, `floor/`, `floor-quotient`, `floor-remainder`, `truncate/`, `truncate-quotient`,
@@ -15,6 +26,7 @@
   `truncate-remainder`, `quotient`, `remainder`, `modulo`
  - Class Tokenizer updated to recognize rational numbers.
  - Test suite file `base_tests.scm` expanded.
+ - File `README.md` Added mentions to new procedures.
 
 ### Fixed
 - File `primitive_builder.rb` Fixed and extended implementation of `/`procedure

data/README.md

@@ -254,7 +254,7 @@ This section lists the implemented standard procedures
 * Number-level: `number?`, `complex?`, `real?`, `rational?`, `integer?`, `zero?`, `exact?`, `inexact?`, `exact-integer?` , `+`, `-`, `*`, `/`,
 `=`, `square`, `number->string`
 * Real-level: `positive?`, `negative?`, `<`, `>`, `<=`, `>=`, `abs`, `max`, `min`,  `floor/`, `floor-quotient`, `floor-remainder`, `truncate/`, `truncate-quotient`,
-  `truncate-remainder`, `quotient`, `remainder`, `modulo`
+  `truncate-remainder`, `quotient`, `remainder`, `modulo`, `gcd`, `lcm`, `numerator`, `denominator`, `floor`, `ceiling`, `truncate`, `round`
 * Integer-level: `even?`, `odd?`
 
 #### List procedures

data/lib/skeem/interpreter.rb

@@ -29,12 +29,12 @@ module Skeem
       @parser ||= Parser.new
       @ptree = parser.parse(source)
       # $stderr.puts @ptree.root.inspect if mode.nil?
-      # require 'debug' unless mode.nil?      
+      # require 'debug' unless mode.nil?
     end
-    
+
     def run(source, mode = nil)
       parse(source, mode)
-      # require 'debug' unless mode.nil?       
+      # require 'debug' unless mode.nil?
       @ptree.root.evaluate(runtime)
     end
 

data/lib/skeem/primitive/primitive_builder.rb

@@ -53,6 +53,13 @@ module Skeem
         create_divide(aRuntime)
         create_floor_slash(aRuntime)
         create_truncate_slash(aRuntime)
+        create_gcd(aRuntime)
+        create_lcm(aRuntime)
+        create_numerator(aRuntime)
+        create_denominator(aRuntime)
+        create_floor(aRuntime)
+        create_ceiling(aRuntime)
+        create_round(aRuntime)
       end
 
       def add_comparison(aRuntime)
@@ -252,6 +259,94 @@ module Skeem
         define_primitive_proc(aRuntime, 'truncate/', binary, primitive)
       end
 
+      def create_gcd(aRuntime)
+        primitive = ->(_runtime, arglist) do
+          if arglist.empty?
+            integer(0)
+          else
+            first_one = arglist.shift
+            divisor = first_one.value
+
+            arglist.each do |elem|
+              divisor = divisor.gcd(elem.value)
+              break if divisor == 1
+            end
+
+            to_datum(divisor)
+          end
+        end
+        define_primitive_proc(aRuntime, 'gcd', zero_or_more, primitive)
+      end
+
+      def create_lcm(aRuntime)
+        primitive = ->(_runtime, arglist) do
+          if arglist.empty?
+            integer(1)
+          else
+            values = arglist.map(&:value)
+            multiple = values.reduce(1, :lcm)
+
+            to_datum(multiple)
+          end
+        end
+        define_primitive_proc(aRuntime, 'lcm', zero_or_more, primitive)
+      end
+
+      def create_numerator(aRuntime)
+        primitive = ->(_runtime, arg_evaluated) do
+          case arg_evaluated
+            when SkmInteger
+              result = arg_evaluated
+            when SkmRational, SkmReal
+              result = integer(arg_evaluated.value.numerator)
+          end
+          result
+        end
+
+        define_primitive_proc(aRuntime, 'numerator', unary, primitive)
+      end
+
+      def create_denominator(aRuntime)
+        primitive = ->(_runtime, arg_evaluated) do
+          case arg_evaluated
+            when SkmInteger
+              result = 1
+            when SkmRational, SkmReal
+              result = arg_evaluated.value.denominator
+          end
+          integer(result)
+        end
+
+        define_primitive_proc(aRuntime, 'denominator', unary, primitive)
+      end
+
+      def create_floor(aRuntime)
+        primitive = ->(_runtime, arg_evaluated) do
+          result = arg_evaluated.value.floor
+          integer(result)
+        end
+
+        define_primitive_proc(aRuntime, 'floor', unary, primitive)
+      end
+
+      def create_ceiling(aRuntime)
+        primitive = ->(_runtime, arg_evaluated) do
+          result = arg_evaluated.value.ceil
+          integer(result)
+        end
+
+        define_primitive_proc(aRuntime, 'ceiling', unary, primitive)
+      end
+
+      def create_round(aRuntime)
+        primitive = ->(_runtime, arg_evaluated) do
+          result = arg_evaluated.value.round
+          integer(result)
+        end
+
+        define_primitive_proc(aRuntime, 'round', unary, primitive)
+      end
+
       def core_eqv?(eval_arg1, eval_arg2)
         raw_result = eval_arg1.eqv?(eval_arg2)
         boolean(raw_result)

data/lib/skeem/standard/base.skm

@@ -3,9 +3,9 @@
 ;; (exact-integer? z)
 (define exact-integer?
   (lambda (z)
-    (and 
+    (and
       (exact? z)
-      (integer? z)))) 
+      (integer? z))))
 
 ;; (zero? z)
 ;; Returns true iff z is zero
@@ -15,7 +15,7 @@
       #t
       #f)))
 
-; (positive? x)      
+; (positive? x)
 ; Return true if x greater than zero; false otherwise
 (define positive?
   (lambda (x)
@@ -24,7 +24,7 @@
       #f)))
 
 ; (negative? x)
-; Returns true iff x < 0      
+; Returns true iff x < 0
 (define negative?
   (lambda (x)
     (if (< x 0)
@@ -32,11 +32,11 @@
       #f)))
 
 ; (inexact? z)
-; Returns true iff z is not an exact number      
+; Returns true iff z is not an exact number
 (define inexact?
-  (lambda (z) 
+  (lambda (z)
     (not (exact? z))))
-    
+
 (define floor-quotient
   (lambda (n1 n2)
     (car (floor/ n1 n2))))
@@ -44,7 +44,7 @@
 (define floor-remainder
   (lambda (n1 n2)
     (cdr (floor/ n1 n2))))
-    
+
 (define truncate-quotient
   (lambda (n1 n2)
     (car (truncate/ n1 n2))))
@@ -57,17 +57,24 @@
 (define quotient
   (lambda (x y)
     (truncate-quotient x y)))
-    
+
 ; For R5RS compatibility
 (define remainder
   (lambda (x y)
     (truncate-remainder x y)))
-    
+
 ; For R5RS compatibility
 (define modulo
   (lambda (x y)
     (floor-remainder x y)))
 
+(define truncate
+  (lambda (x)
+    (if (positive? x)
+      (floor x)
+      (ceiling x)
+    )))
+
 ; (odd? n)
 ; Returns true iff n is odd
 (define odd?
@@ -102,47 +109,47 @@
   (if obj #f #t))
 
 ; (list arg ...)
-; Allocates and returns a new list from its arguments   
+; Allocates and returns a new list from its arguments
 (define list
   (lambda args args))
- 
-(define caar 
+
+(define caar
   (lambda (x)
     (car (car x))))
 
-(define cadr 
-  (lambda (x) 
+(define cadr
+  (lambda (x)
     (car (cdr x))))
 
-(define cdar 
+(define cdar
  (lambda(x)
    (cdr (car x))))
 
-(define cddr 
- (lambda (x) 
+(define cddr
+ (lambda (x)
    (cdr (cdr x))))
 
-;; (list-ref list n)    
+;; (list-ref list n)
 ;; Return the nth (sero-based) element of list
 ;; n must be a nonnegative integer
 ;(define list-ref
 ;  (lambda (ls n)
 ;    (if (= n 0)
 ;        (car ls)
-;        (list-ref (cdr ls) (- n 1))))) 
- 
+;        (list-ref (cdr ls) (- n 1)))))
+
 (define symbol=? string=?)
 
 ;; Test the equivalence (with eqv? predicate) between an expected value and
 ;; an expression
 ;; (test-eqv expected test-expr)
-(define test-eqv 
-  (lambda (x y) 
+(define test-eqv
+  (lambda (x y)
     (test-assert (eqv? x y))))
 
 ;; Test the equality (with equal? predicate) between an expected value and
 ;; an expression
 ;; (test-equal expected test-expr)
-(define test-equal 
-  (lambda (x y) 
+(define test-equal
+  (lambda (x y)
     (test-assert (equal? x y))))

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.2.10'.freeze
+  VERSION = '0.2.11'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -5,6 +5,7 @@ require_relative '../../lib/skeem/interpreter' # Load the class under test
 
 module Skeem
   describe Interpreter do
+    include InterpreterSpec
     include DatumDSL
 
     context 'Initialization:' do
@@ -39,13 +40,12 @@ module Skeem
     context 'Interpreting self-evaluating expressions' do
       it 'should evaluate isolated booleans' do
         samples = [
-        ['#f', false],
-        ['#false', false],
-        ['#t', true],
-        ['#true', true]
-      ]
-        samples.each do |source, predicted|
-          result = subject.run(source)
+          ['#f', false],
+          ['#false', false],
+          ['#t', true],
+          ['#true', true]
+        ]
+        compare_to_predicted(samples) do |result, predicted|
           expect(result).to be_kind_of(SkmBoolean)
           expect(result).to eq(predicted)
         end
@@ -59,8 +59,7 @@ module Skeem
           ['+12345', 12345],
           ['-12345', -12345]
         ]
-        samples.each do |source, predicted|
-          result = subject.run(source)
+        compare_to_predicted(samples) do |result, predicted|
           expect(result).to be_kind_of(SkmInteger)
           expect(result).to eq(predicted)
         end
@@ -74,8 +73,7 @@ module Skeem
           ['+123e+45', 123e+45],
           ['-123e-45', -123e-45]
         ]
-        samples.each do |source, predicted|
-          result = subject.run(source)
+        compare_to_predicted(samples) do |result, predicted|
           expect(result).to be_kind_of(SkmReal)
           expect(result).to eq(predicted)
         end
@@ -83,10 +81,9 @@ module Skeem
 
       it 'should evaluate isolated strings' do
         samples = [
-        ['"Hello, world"', 'Hello, world']
-      ]
-        samples.each do |source, predicted|
-          result = subject.run(source)
+          ['"Hello, world"', 'Hello, world']
+        ]
+        compare_to_predicted(samples) do |result, predicted|
           expect(result).to be_kind_of(SkmString)
           expect(result).to eq(predicted)
         end
@@ -132,10 +129,7 @@ SKEEM
           ['(if (> 3 2) "yes")', 'yes'],
           ['(if (> 2 3) "yes")', SkmUndefined.instance]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the complete conditional form' do
@@ -143,10 +137,7 @@ SKEEM
           ['(if (> 3 2) "yes" "no")', 'yes'],
           ['(if (> 2 3) "yes" "no")', 'no']
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
         source = <<-SKEEM
   ; Example from R7RS section 4.1.5
   (if (> 3 2)
@@ -156,7 +147,7 @@ SKEEM
         result = subject.run(source)
         expect(result).to eq(1)
       end
-      
+
       it 'should implement the cond form' do
         source = <<-SKEEM
   (define signum (lambda (x)
@@ -166,17 +157,15 @@ SKEEM
       ((< x 0) -1)
     )))
 SKEEM
-       result = subject.run(source)
-       result = subject.run('(signum 3)')
-       expect(result).to eq(1)
-       
-       result = subject.run('(signum 0)')
-       expect(result).to eq(0)
-
-       result = subject.run('(signum -3)')
-       expect(result).to eq(-1)       
+        result = subject.run(source)
+        checks = [
+          ['(signum 3)', 1],
+          ['(signum 0)', 0],
+          ['(signum -3)', -1]
+        ]
+        compare_to_predicted(checks)
       end
-      
+
       it 'should implement the cond form with arrows' do
         source = <<-SKEEM
   (define signum (lambda (x)
@@ -186,16 +175,14 @@ SKEEM
       ((< x 0) => -1)
     )))
 SKEEM
-       result = subject.run(source)
-       result = subject.run('(signum 3)')
-       expect(result).to eq(1)
-       
-       result = subject.run('(signum 0)')
-       expect(result).to eq(0)
-
-       result = subject.run('(signum -3)')
-       expect(result).to eq(-1)       
-      end 
+        result = subject.run(source)
+        checks = [
+          ['(signum 3)', 1],
+          ['(signum 0)', 0],
+          ['(signum -3)', -1]
+        ]
+        compare_to_predicted(checks)
+      end
 
       it 'should implement the cond ... else form' do
         source = <<-SKEEM
@@ -206,16 +193,22 @@ SKEEM
       (else -1)
     )))
 SKEEM
-       result = subject.run(source)
-       result = subject.run('(signum 3)')
-       expect(result).to eq(1)
-       
-       result = subject.run('(signum 0)')
-       expect(result).to eq(0)
+        result = subject.run(source)
+        checks = [
+          ['(signum 3)', 1],
+          ['(signum 0)', 0],
+          ['(signum -3)', -1]
+        ]
+        compare_to_predicted(checks)
+      end
 
-       result = subject.run('(signum -3)')
-       expect(result).to eq(-1)       
-      end      
+      it 'should implement the truncate procedure' do
+        checks = [
+          ['(truncate -4.3)', -4],
+          ['(truncate 3.5)', 3]
+        ]
+        compare_to_predicted(checks)
+      end
 
       it 'should implement the quotation of constant literals' do
          checks = [
@@ -228,10 +221,7 @@ SKEEM
           ["'\"abc\"", 'abc'],
           ["'#t", true]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the quotation of vectors' do
@@ -280,12 +270,12 @@ SKEEM
         subject.run(source)
         procedure = subject.fetch('abs')
         expect(procedure.arity).to eq(1)
-        result = subject.run('(abs -3)')
-        expect(result).to eq(3)
-        result = subject.run('(abs 0)')
-        expect(result).to eq(0)
-        result = subject.run('(abs 3)')
-        expect(result).to eq(3)
+        checks = [
+          ['(abs -3)', 3],
+          ['(abs 0)', 0],
+          ['(abs 3)', 3]
+        ]
+        compare_to_predicted(checks)
       end
 
       it 'should implement the lambda function with two args' do
@@ -298,12 +288,12 @@ SKEEM
         subject.run(source)
         procedure = subject.fetch('min')
         expect(procedure.arity).to eq(2)
-        result = subject.run('(min 1 2)')
-        expect(result).to eq(1)
-        result = subject.run('(min 2 1)')
-        expect(result).to eq(1)
-        result = subject.run('(min 2 2)')
-        expect(result).to eq(2)
+        checks = [
+          ['(min 1 2)', 1],
+          ['(min 2 1)', 1],
+          ['(min 2 2)', 2]
+        ]
+        compare_to_predicted(checks)
       end
 
       it 'should implement recursive functions' do
@@ -377,8 +367,8 @@ SKEEM
         result = subject.run(source)
         expect(result.last.value).to eq(20)
       end
-      
-      
+
+
     end # context
 
     context 'Binding constructs:' do
@@ -412,8 +402,7 @@ SKEEM
     (z (+ x y)))
   (* z x)))
 SKEEM
-        result = subject.run(source)
-        expect(result).to eq(35)
+        expect_expr(source).to eq(35)
       end
 
       it 'should support the nesting of a lambda in a let expression' do
@@ -444,8 +433,7 @@ SKEEM
       (z (+ x y)))
       (* z x)))
 SKEEM
-        result = subject.run(source)
-        expect(result).to eq(70)
+        expect_expr(source).to eq(70)
       end
     end # context
 
@@ -470,7 +458,7 @@ SKEEM
         result = subject.run(source)
         expect(result).to eq(7)
       end
-      
+
       it 'should support begin as lambda body' do
         source = <<-SKEEM
   (define kube (lambda (x)
@@ -484,7 +472,7 @@ SKEEM
 SKEEM
         result = subject.run(source)
         expect(result.last).to eq(64)
-      end      
+      end
     end # context
 
     context 'Quasiquotation:' do
@@ -499,10 +487,7 @@ SKEEM
           ['`"abc"', 'abc'],
           ['`#t', true]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the quasiquotation of vectors' do
@@ -654,10 +639,7 @@ SKEEM
           ['(zero? 3)', false],
           ['(zero? -3)', false]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the positive? predicate' do
@@ -669,10 +651,7 @@ SKEEM
           ['(positive? 3)', true],
           ['(positive? -3)', false]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the negative? predicate' do
@@ -684,10 +663,7 @@ SKEEM
           ['(negative? 3)', false],
           ['(negative? -3)', true]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the even? predicate' do
@@ -697,10 +673,7 @@ SKEEM
           ['(even? 2.0)', true],
           ['(even? -120762398465)', false]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the odd? predicate' do
@@ -710,10 +683,7 @@ SKEEM
           ['(odd? 2.0)', false],
           ['(odd? -120762398465)', true]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the abs function' do
@@ -725,10 +695,7 @@ SKEEM
           ['(abs 3)', 3],
           ['(abs -7)', 7]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the square function' do
@@ -737,10 +704,7 @@ SKEEM
           ['(square 2.0)', 4.0],
           ['(square -7)', 49]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the not procedure' do
@@ -753,10 +717,7 @@ SKEEM
           ['(not (list))', false],
           ["(not 'nil)", false]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the list procedure' do
@@ -766,8 +727,7 @@ SKEEM
           ['(list 1 2 3 4)', [1, 2, 3, 4]],
           ["(list 'a (+ 3 4) 'c)", [identifier('a'), 7, identifier('c')]]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
+        compare_to_predicted(checks) do |result, expectation|
           expect(result.to_a).to eq(expectation)
         end
       end
@@ -777,10 +737,7 @@ SKEEM
           ["(caar '((a)))", 'a'],
           ["(caar '((1 2) 3 4))", 1]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the cadr procedure' do
@@ -788,18 +745,14 @@ SKEEM
           ["(cadr '(a b c))", 'b'],
           ["(cadr '((1 2) 3 4))", 3]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the cdar procedure' do
         checks = [
           ["(cdar '((7 6 5 4 3 2 1) 8 9))", [6, 5, 4, 3, 2, 1]]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
+        compare_to_predicted(checks) do |result, expectation|
           expect(result.to_a).to eq(expectation)
         end
       end
@@ -808,8 +761,7 @@ SKEEM
         checks = [
           ["(cddr '(2 1))", []]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
+        compare_to_predicted(checks) do |result, expectation|
           expect(result.to_a).to eq(expectation)
         end
       end
@@ -820,10 +772,7 @@ SKEEM
           ["(symbol=? 'a (string->symbol \"a\"))", true],
           ["(symbol=? 'a 'b)", false]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
 
       it 'should implement the floor-quotient procedure' do
@@ -833,12 +782,9 @@ SKEEM
           ['(floor-quotient 5 -2)', -3],
           ['(floor-quotient -5 -2)', 2]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
-      
+
       it 'should implement the floor-remainder (modulo) procedure' do
         checks = [
           ['(floor-remainder 16 4)', 0],
@@ -850,14 +796,11 @@ SKEEM
           ['(modulo 5 2)', 1],
           ['(modulo -45.0 7)', 4.0],
           ['(modulo 10.0 -3.0)', -2.0],
-          ['(modulo -17 -9)', -8]          
+          ['(modulo -17 -9)', -8]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
+        compare_to_predicted(checks)
       end
-      
+
         it 'should implement the truncate-quotient procedure' do
           checks = [
             ['(truncate-quotient 5 2)', 2],
@@ -867,12 +810,9 @@ SKEEM
             ['(quotient 5 2)', 2],
             ['(quotient -5 2)', -2],
             ['(quotient 5 -2)', -2],
-            ['(quotient -5 -2)', 2]            
+            ['(quotient -5 -2)', 2]
           ]
-          checks.each do |(skeem_expr, expectation)|
-            result = subject.run(skeem_expr)
-            expect(result).to eq(expectation)
-          end
+          compare_to_predicted(checks)
         end
 
         it 'should implement the truncate-remainder procedure' do
@@ -884,23 +824,17 @@ SKEEM
             ['(remainder 5 2)', 1],
             ['(remainder -5 2)', -1],
             ['(remainder 5 -2)', 1],
-            ['(remainder -5 -2)', -1]            
+            ['(remainder -5 -2)', -1]
           ]
-          checks.each do |(skeem_expr, expectation)|
-            result = subject.run(skeem_expr)
-            expect(result).to eq(expectation)
-          end
+          compare_to_predicted(checks)
         end
-      
+
       it 'should implement the test-equal procedure' do
         checks = [
           ["(test-equal (cons 1 2) (cons 1 2))", true]
         ]
-        checks.each do |(skeem_expr, expectation)|
-          result = subject.run(skeem_expr)
-          expect(result).to eq(expectation)
-        end
-      end      
+        compare_to_predicted(checks)
+      end
     end # context
 
     context 'Second-order functions' do