skeem 0.2.21 → 0.2.22

data/lib/skeem/tokenizer.rb

@@ -25,7 +25,7 @@ module Skeem
     # @return [Integer] Offset of start of current line
     attr_reader(:line_start)
 
-    @@lexeme2name = {
+    Lexeme2name = {
       "'" => 'APOSTROPHE',
       '=>' => 'ARROW',
       '`' => 'GRAVE_ACCENT',
@@ -40,7 +40,7 @@ module Skeem
     }.freeze
 
     # Here are all the implemented Scheme keywords (in uppercase)
-    @@keywords = %w[
+    Keywords = %w[
       BEGIN
       COND
       DEFINE
@@ -66,11 +66,11 @@ module Skeem
     # @param source [String] Skeem text to tokenize.
     def initialize(source)
       @scanner = StringScanner.new('')
-      reinitialize(source)
+      reset(source)
     end
 
     # @param source [String] Skeem text to tokenize.
-    def reinitialize(source)
+    def reset(source)
       @scanner.string = source
       @lineno = 1
       @line_start = 0
@@ -84,7 +84,7 @@ module Skeem
         tok_sequence << token unless token.nil?
       end
 
-      return tok_sequence
+      tok_sequence
     end
 
     private
@@ -100,11 +100,11 @@ module Skeem
 
       if "()'`".include? curr_ch
         # Delimiters, separators => single character token
-        token = build_token(@@lexeme2name[curr_ch], scanner.getch)
+        token = build_token(Lexeme2name[curr_ch], scanner.getch)
       elsif (lexeme = scanner.scan(/(?:\.|_)(?=\s|\()/)) # Single char occurring alone
-        token = build_token(@@lexeme2name[curr_ch], scanner.getch)
+        token = build_token(Lexeme2name[curr_ch], scanner.getch)
       elsif (lexeme = scanner.scan(/(?:,@?)|(?:=>)|(?:\.\.\.)/))
-        token = build_token(@@lexeme2name[lexeme], lexeme)
+        token = build_token(Lexeme2name[lexeme], lexeme)
       elsif (token = recognize_char_token)
         # Do nothing
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+\/[0-9]+(?=\s|[|()";]|$)/))
@@ -121,7 +121,7 @@ module Skeem
       elsif (lexeme = scanner.scan(/"(?:\\"|[^"])*"/)) # Double quotes literal?
         token = build_token('STRING_LIT', lexeme)
       elsif (lexeme = scanner.scan(/[a-zA-Z!$%&*\/:<=>?@^_~][a-zA-Z0-9!$%&*+-.\/:<=>?@^_~+-]*/))
-        keyw = @@keywords[lexeme.upcase]
+        keyw = Keywords[lexeme.upcase]
         tok_type = keyw || 'IDENTIFIER'
         token = build_token(tok_type, lexeme)
       elsif (lexeme = scanner.scan(/\|(?:[^|])*\|/)) # Vertical bar delimited
@@ -142,7 +142,7 @@ module Skeem
         raise ScanError, "Unknown token #{erroneous} on line #{lineno}"
       end
 
-      return token
+      token
     end
 
     # rubocop: enable Lint/DuplicateBranch
@@ -160,15 +160,15 @@ other literal data (section 2.4).
       when /^#true|false|t|f$/
         token = build_token('BOOLEAN', aLexeme)
       when '#('
-        token = build_token(@@lexeme2name[aLexeme], aLexeme)
+        token = build_token(Lexeme2name[aLexeme], aLexeme)
       end
 
-      return token
+      token
     end
 
     def recognize_char_token
       token = nil
-      if (lexeme = scanner.scan(/#\\/))
+      if (lexeme = scanner.scan("#\\"))
         if (lexeme = scanner.scan(/(?:alarm|backspace|delete|escape|newline|null|return|space|tab)/))
           token = build_token('CHAR', lexeme, :name)
         elsif (lexeme = scanner.scan(/x[0-9a-fA-F]+/))
@@ -193,7 +193,7 @@ other literal data (section 2.4).
         raise e
       end
 
-      return token
+      token
     end
 
     def convert_to(aLexeme, aSymbolName, aFormat)
@@ -218,7 +218,7 @@ other literal data (section 2.4).
         value = aLexeme
       end
 
-      return [value, symb]
+      [value, symb]
     end
 
     def to_boolean(aLexeme, _format)
@@ -333,8 +333,6 @@ other literal data (section 2.4).
     end
 
     def skip_intertoken_spaces
-      pre_pos = scanner.pos
-
       loop do
         ws_found = scanner.skip(/[ \t\f]+/) ? true : false
         nl_found = scanner.skip(/(?:\r\n)|\r|\n/)
@@ -354,9 +352,6 @@ other literal data (section 2.4).
         end
         break unless ws_found || cmt_found
       end
-
-      curr_pos = scanner.pos
-      return if curr_pos == pre_pos
     end
 
     def skip_block_comment

data/lib/skeem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Skeem
-  VERSION = '0.2.21'
+  VERSION = '0.2.22'
 end

data/lib/skeem.rb

@@ -4,7 +4,7 @@
 # This file acts as a jumping-off point for loading dependencies expected
 # for a Skeem client.
 
-require_relative './skeem/version'
-require_relative './skeem/interpreter'
+require_relative 'skeem/version'
+require_relative 'skeem/interpreter'
 
 # End of file

data/skeem.gemspec

@@ -54,7 +54,8 @@ DESCR
 SUMMARY
   spec.homepage      = 'https://github.com/famished-tiger/Skeem'
   spec.license       = 'MIT'
-  spec.required_ruby_version = '>= 2.6.0'
+  spec.required_ruby_version = '>= 3.1.0'
+  spec.metadata = { 'rubygems_mfa_required' => 'true' }
 
   spec.bindir = 'bin'
   spec.executables << 'skeem'
@@ -62,10 +63,12 @@ SUMMARY
   PkgExtending.pkg_files(spec)
   PkgExtending.pkg_documentation(spec)
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.8.11'
+  spec.add_dependency 'rley', '~> 0.9', '>= 0.9.02'
 
   # Development dependencies
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '>= 12.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'benchmark', '~> 0.4.0'
+  spec.add_development_dependency 'bundler', '~> 2.4', '>= 2.4.1'
+  spec.add_development_dependency 'ostruct', '~> 0.6.1'
+  spec.add_development_dependency 'rake', '~> 13'
+  spec.add_development_dependency 'rspec', '~> 3', '>= 3.10.0'
 end

data/spec/skeem/datum_dsl_spec.rb

@@ -8,9 +8,9 @@ require_relative '../../lib/skeem/datum_dsl'
 
 module Skeem
   describe DatumDSL do
-    subject do
+    subject(:dsl) do
       obj = Object.new
-      obj.extend(DatumDSL) # use the mixin module
+      obj.extend(described_class) # use the mixin module
       obj
     end
 
@@ -83,140 +83,140 @@ module Skeem
     end
 
     context 'Simple datums:' do
-      it 'should convert boolean literals' do
+      it 'concerts boolean literals' do
         boolean_tests.each do |(literal, predicted)|
-          expect(subject.boolean(literal)).to eq(predicted)
+          expect(dsl.boolean(literal)).to eq(predicted)
         end
       end
 
-      it 'should convert integer literals' do
+      it 'concerts integer literals' do
         integer_tests.each do |(literal, predicted)|
-          expect(subject.integer(literal)).to eq(predicted)
+          expect(dsl.integer(literal)).to eq(predicted)
         end
       end
 
-      it 'should convert rational literals' do
+      it 'concerts rational literals' do
         rational_tests.each do |(literal, predicted)|
-          expect(subject.rational(literal)).to eq(predicted)
+          expect(dsl.rational(literal)).to eq(predicted)
         end
       end
 
-      it 'should convert real number literals' do
+      it 'concerts real number literals' do
         real_tests.each do |(literal, predicted)|
-          expect(subject.real(literal)).to eq(predicted)
+          expect(dsl.real(literal)).to eq(predicted)
         end
       end
 
-      it 'should convert string literals' do
+      it 'concerts string literals' do
         string_tests.each do |(literal, predicted)|
-          expect(subject.string(literal)).to eq(predicted)
+          expect(dsl.string(literal)).to eq(predicted)
         end
       end
 
-      it 'should convert identifier literals' do
+      it 'concerts identifier literals' do
         identifier_tests.each do |(literal, predicted)|
-          expect(subject.identifier(literal)).to eq(predicted)
+          expect(dsl.identifier(literal)).to eq(predicted)
         end
       end
     end # context
 
 
     context 'Compound datums:' do
-      it 'should convert empty array into one-member list' do
-        result = subject.list([])
-        expect(result).to be_kind_of(SkmEmptyList)
+      it 'concerts empty array into one-member list' do
+        result = dsl.list([])
+        expect(result).to be_a(SkmEmptyList)
         expect(result).to be_null
       end
 
-      it 'should convert array of simple datums into list' do
+      it 'concerts array of simple datums into list' do
         literals = simple_datum_tests.map { |(datum, _predicted)| datum }
         predictions = simple_datum_tests.map { |(_datum, predicted)| predicted }
-        list_result = subject.list(literals)
-        expect(list_result).to be_kind_of(SkmPair)
+        list_result = dsl.list(literals)
+        expect(list_result).to be_a(SkmPair)
         list_result.to_a.each_with_index do |member, index|
           expect(member).to eq(predictions[index])
         end
       end
 
-      it 'should convert a single datum into one-member list' do
-        result = subject.list('123')
-        expect(result).to be_kind_of(SkmPair)
+      it 'concerts a single datum into one-member list' do
+        result = dsl.list('123')
+        expect(result).to be_a(SkmPair)
         expect(result.car).to eq(123)
       end
 
-      it 'should convert empty array into one-member list' do
-        result = subject.vector([])
-        expect(result).to be_kind_of(SkmVector)
+      it 'concerts empty array into one-member list' do
+        result = dsl.vector([])
+        expect(result).to be_a(SkmVector)
         expect(result.members).to be_empty
       end
 
 
-      it 'should convert array of simple datums into vector' do
+      it 'concerts array of simple datums into vector' do
         literals = simple_datum_tests.map { |(datum, _predicted)| datum }
         predictions = simple_datum_tests.map { |(_datum, predicted)| predicted }
-        vector_result = subject.vector(literals)
-        expect(vector_result).to be_kind_of(SkmVector)
+        vector_result = dsl.vector(literals)
+        expect(vector_result).to be_a(SkmVector)
         vector_result.members.each_with_index do |member, index|
           expect(member).to eq(predictions[index])
         end
       end
 
-      it 'should convert a single datum into one-member vector' do
-        result = subject.vector('123')
-        expect(result).to be_kind_of(SkmVector)
+      it 'concerts a single datum into one-member vector' do
+        result = dsl.vector('123')
+        expect(result).to be_a(SkmVector)
         expect(result.members.first).to eq(123)
       end
     end # context
 
     context 'Arbitrary datums:' do
-      it 'should recognize & convert booleans' do
+      it 'recognizes & convert booleans' do
         boolean_tests.each do |(literal, predicted)|
-          expect(subject.to_datum(literal)).to eq(predicted)
+          expect(dsl.to_datum(literal)).to eq(predicted)
         end
       end
 
-      it 'should recognize & convert integer literals' do
+      it 'recognizes & convert integer literals' do
         integer_tests.each do |(literal, predicted)|
-          expect(subject.to_datum(literal)).to eq(predicted)
+          expect(dsl.to_datum(literal)).to eq(predicted)
         end
       end
 
-      it 'should recognize & convert rational literals' do
+      it 'recognizes & convert rational literals' do
         rational_tests.each do |(literal, predicted)|
-          expect(subject.to_datum(literal)).to eq(predicted)
+          expect(dsl.to_datum(literal)).to eq(predicted)
         end
       end
 
-      it 'should recognize & convert real number literals' do
+      it 'recognizes & convert real number literals' do
         real_tests.each do |(literal, predicted)|
-          expect(subject.to_datum(literal)).to eq(predicted)
+          expect(dsl.to_datum(literal)).to eq(predicted)
         end
       end
 
-      it 'should recognize & convert string literals' do
+      it 'recognizes & convert string literals' do
         string_tests.each do |(literal, predicted)|
-          expect(subject.to_datum(literal)).to eq(predicted)
+          expect(dsl.to_datum(literal)).to eq(predicted)
         end
       end
 
-      it 'should convert nested compound datums' do
+      it 'concerts nested compound datums' do
         literals = [
           'false', '123', '-1.41',
           'foo', SkmVector.new(['uno', '2', 3.0]), 'bar'
         ]
-        result = subject.list(literals)
-        expect(result).to be_kind_of(SkmPair)
+        result = dsl.list(literals)
+        expect(result).to be_a(SkmPair)
         expect(result.to_a).to eq([false, 123, -1.41, 'foo', ['uno', 2, 3], 'bar'])
       end
     end
 
-    it 'should duplicate a given list' do
-      f = subject.identifier('f')
-      g = subject.identifier('g')
-      one_list = subject.list([f, g])
+    it 'duplicates a given list' do
+      f = dsl.identifier('f')
+      g = dsl.identifier('g')
+      one_list = dsl.list([f, g])
       expect(one_list).to be_list
       expect(one_list.to_a).to eq([f, g])
-      duplicate = subject.to_datum(one_list)
+      duplicate = dsl.to_datum(one_list)
       expect(duplicate).to be_list
       # $stderr.puts duplicate.inspect
       expect(duplicate.to_a).to eq([f, g])

data/spec/skeem/element_visitor_spec.rb

@@ -19,19 +19,19 @@ module Skeem
     end
 
     # Default instantiation rule
-    subject { SkmElementVisitor.new(simple_datum) }
+    subject(:visitor) { described_class.new(simple_datum) }
 
     context 'Standard creation & initialization:' do
-      it 'should be initialized with a parse tree argument' do
-        expect { SkmElementVisitor.new(simple_datum) }.not_to raise_error
+      it 'is initialized with a parse tree argument' do
+        expect { described_class.new(simple_datum) }.not_to raise_error
       end
 
-      it 'should know the parse tree to visit' do
-        expect(subject.root).to eq(simple_datum)
+      it 'knows the parse tree to visit' do
+        expect(visitor.root).to eq(simple_datum)
       end
 
-      it "shouldn't have subscribers at start" do
-        expect(subject.subscribers).to be_empty
+      it "doesn't have subscribers at start" do
+        expect(visitor.subscribers).to be_empty
       end
     end # context
 
@@ -39,137 +39,137 @@ module Skeem
       let(:listener1) { double('fake-subscriber1') }
       let(:listener2) { double('fake-subscriber2') }
 
-      it 'should allow subscriptions' do
-        subject.subscribe(listener1)
-        expect(subject.subscribers.size).to eq(1)
-        expect(subject.subscribers).to eq([listener1])
+      it 'allows subscriptions' do
+        visitor.subscribe(listener1)
+        expect(visitor.subscribers.size).to eq(1)
+        expect(visitor.subscribers).to eq([listener1])
 
-        subject.subscribe(listener2)
-        expect(subject.subscribers.size).to eq(2)
-        expect(subject.subscribers).to eq([listener1, listener2])
+        visitor.subscribe(listener2)
+        expect(visitor.subscribers.size).to eq(2)
+        expect(visitor.subscribers).to eq([listener1, listener2])
       end
 
-      it 'should allow un-subcriptions' do
-        subject.subscribe(listener1)
-        subject.subscribe(listener2)
-        subject.unsubscribe(listener2)
-        expect(subject.subscribers.size).to eq(1)
-        expect(subject.subscribers).to eq([listener1])
-        subject.unsubscribe(listener1)
-        expect(subject.subscribers).to be_empty
+      it 'allows un-subcriptions' do
+        visitor.subscribe(listener1)
+        visitor.subscribe(listener2)
+        visitor.unsubscribe(listener2)
+        expect(visitor.subscribers.size).to eq(1)
+        expect(visitor.subscribers).to eq([listener1])
+        visitor.unsubscribe(listener1)
+        expect(visitor.subscribers).to be_empty
       end
     end # context
 
     context 'Visiting simple datum:' do
       let(:runtime) { double('fake-runtime') }
 
-      it 'should allow the visit of simple datum object' do
-        subject.subscribe(listener)
-        expect(listener).to receive(:before_simple_datum).with(runtime, simple_datum)
-        expect(listener).to receive(:after_simple_datum).with(runtime, simple_datum)
-        subject.start(runtime)
-        expect(subject.runtime).to eq(runtime)
+      it 'allows the visit of simple datum object' do
+        visitor.subscribe(listener)
+        allow(listener).to receive(:before_simple_datum).with(runtime, simple_datum)
+        allow(listener).to receive(:after_simple_datum).with(runtime, simple_datum)
+        visitor.start(runtime)
+        expect(visitor.runtime).to eq(runtime)
       end
     end # context
 
     context 'Visiting compound datum:' do
       let(:runtime) { double('fake-runtime') }
 
-      it 'should allow the visit of a flat list' do
+      it 'allows the visit of a flat list' do
         ls = list ['#false', 3, 'foo']
-        instance = SkmElementVisitor.new(ls)
+        instance = described_class.new(ls)
         instance.subscribe(listener)
-        expect(listener).to receive(:before_pair).with(runtime, ls).ordered
-        expect(listener).to receive(:before_car).with(runtime, ls, ls.car).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, ls.car).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, ls.car).ordered
-        expect(listener).to receive(:after_car).with(runtime, ls, ls.car).ordered
-        expect(listener).to receive(:before_cdr).with(runtime, ls, ls.cdr).ordered
-        expect(listener).to receive(:before_pair).with(runtime, ls.cdr).ordered
-        expect(listener).to receive(:before_car).with(runtime, ls.cdr, ls.cdr.car).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, ls.cdr.car).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, ls.cdr.car).ordered
-        expect(listener).to receive(:after_car).with(runtime, ls.cdr, ls.cdr.car).ordered
-        expect(listener).to receive(:before_cdr).with(runtime, ls.cdr, ls.cdr.cdr).ordered
-        expect(listener).to receive(:before_pair).with(runtime, ls.cdr.cdr).ordered
-        expect(listener).to receive(:before_car).with(runtime, ls.cdr.cdr, ls.cdr.cdr.car).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, ls.cdr.cdr.car).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, ls.cdr.cdr.car).ordered
-        expect(listener).to receive(:after_car).with(runtime, ls.cdr.cdr, ls.cdr.cdr.car).ordered
-        expect(listener).to receive(:before_cdr).with(runtime, ls.cdr.cdr, ls.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:before_empty_list).with(runtime, ls.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:after_empty_list).with(runtime, ls.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:after_cdr).with(runtime, ls.cdr.cdr, ls.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:after_pair).with(runtime, ls.cdr.cdr).ordered
-        expect(listener).to receive(:after_cdr).with(runtime, ls.cdr, ls.cdr.cdr).ordered
-        expect(listener).to receive(:after_pair).with(runtime, ls.cdr).ordered
-        expect(listener).to receive(:after_cdr).with(runtime, ls, ls.cdr).ordered
-        expect(listener).to receive(:after_pair).with(runtime, ls).ordered
+        allow(listener).to receive(:before_pair).with(runtime, ls)
+        allow(listener).to receive(:before_car).with(runtime, ls, ls.car)
+        allow(listener).to receive(:before_simple_datum).with(runtime, ls.car)
+        allow(listener).to receive(:after_simple_datum).with(runtime, ls.car)
+        allow(listener).to receive(:after_car).with(runtime, ls, ls.car)
+        allow(listener).to receive(:before_cdr).with(runtime, ls, ls.cdr)
+        allow(listener).to receive(:before_pair).with(runtime, ls.cdr)
+        allow(listener).to receive(:before_car).with(runtime, ls.cdr, ls.cdr.car)
+        allow(listener).to receive(:before_simple_datum).with(runtime, ls.cdr.car)
+        allow(listener).to receive(:after_simple_datum).with(runtime, ls.cdr.car)
+        allow(listener).to receive(:after_car).with(runtime, ls.cdr, ls.cdr.car)
+        allow(listener).to receive(:before_cdr).with(runtime, ls.cdr, ls.cdr.cdr)
+        allow(listener).to receive(:before_pair).with(runtime, ls.cdr.cdr)
+        allow(listener).to receive(:before_car).with(runtime, ls.cdr.cdr, ls.cdr.cdr.car)
+        allow(listener).to receive(:before_simple_datum).with(runtime, ls.cdr.cdr.car)
+        allow(listener).to receive(:after_simple_datum).with(runtime, ls.cdr.cdr.car)
+        allow(listener).to receive(:after_car).with(runtime, ls.cdr.cdr, ls.cdr.cdr.car)
+        allow(listener).to receive(:before_cdr).with(runtime, ls.cdr.cdr, ls.cdr.cdr.cdr)
+        allow(listener).to receive(:before_empty_list).with(runtime, ls.cdr.cdr.cdr)
+        allow(listener).to receive(:after_empty_list).with(runtime, ls.cdr.cdr.cdr)
+        allow(listener).to receive(:after_cdr).with(runtime, ls.cdr.cdr, ls.cdr.cdr.cdr)
+        allow(listener).to receive(:after_pair).with(runtime, ls.cdr.cdr)
+        allow(listener).to receive(:after_cdr).with(runtime, ls.cdr, ls.cdr.cdr)
+        allow(listener).to receive(:after_pair).with(runtime, ls.cdr)
+        allow(listener).to receive(:after_cdr).with(runtime, ls, ls.cdr)
+        allow(listener).to receive(:after_pair).with(runtime, ls)
         instance.start(runtime)
       end
 
-      it 'should allow the visit of a flat vector' do
+      it 'allows the visit of a flat vector' do
         vec = vector ['#false', 3, 'foo']
-        instance = SkmElementVisitor.new(vec)
+        instance = described_class.new(vec)
         instance.subscribe(listener)
-        expect(listener).to receive(:before_compound_datum).with(runtime, vec).ordered
-        expect(listener).to receive(:before_children).with(runtime, vec, vec.members).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[0]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[0]).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[1]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[1]).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[2]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[2]).ordered
-        expect(listener).to receive(:after_children).with(runtime, vec, vec.members).ordered
-        expect(listener).to receive(:after_compound_datum).with(runtime, vec).ordered
+        allow(listener).to receive(:before_compound_datum).with(runtime, vec)
+        allow(listener).to receive(:before_children).with(runtime, vec, vec.members)
+        allow(listener).to receive(:before_simple_datum).with(runtime, vec.members[0])
+        allow(listener).to receive(:after_simple_datum).with(runtime, vec.members[0])
+        allow(listener).to receive(:before_simple_datum).with(runtime, vec.members[1])
+        allow(listener).to receive(:after_simple_datum).with(runtime, vec.members[1])
+        allow(listener).to receive(:before_simple_datum).with(runtime, vec.members[2])
+        allow(listener).to receive(:after_simple_datum).with(runtime, vec.members[2])
+        allow(listener).to receive(:after_children).with(runtime, vec, vec.members)
+        allow(listener).to receive(:after_compound_datum).with(runtime, vec)
         instance.start(runtime)
       end
 
-      it 'should allow the visit of a nested compound datum' do
+      it 'allows the visit of a nested compound datum' do
         nested_list = list %w[uno twei three']
         vec = vector ['#false', 3, nested_list, 'foo']
-        instance = SkmElementVisitor.new(vec)
+        instance = described_class.new(vec)
         instance.subscribe(listener)
-        expect(listener).to receive(:before_compound_datum).with(runtime, vec).ordered
-        expect(listener).to receive(:before_children).with(runtime, vec, vec.members).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[0]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[0]).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[1]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[1]).ordered
-
-        expect(listener).to receive(:before_pair).with(runtime, nested_list).ordered
-        expect(listener).to receive(:before_car).with(runtime, nested_list, nested_list.car).ordered
+        allow(listener).to receive(:before_compound_datum).with(runtime, vec)
+        allow(listener).to receive(:before_children).with(runtime, vec, vec.members)
+        allow(listener).to receive(:before_simple_datum).with(runtime, vec.members[0])
+        allow(listener).to receive(:after_simple_datum).with(runtime, vec.members[0])
+        allow(listener).to receive(:before_simple_datum).with(runtime, vec.members[1])
+        allow(listener).to receive(:after_simple_datum).with(runtime, vec.members[1])
+
+        allow(listener).to receive(:before_pair).with(runtime, nested_list)
+        allow(listener).to receive(:before_car).with(runtime, nested_list, nested_list.car)
         expect(nested_list.car).to eq('uno')
-        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.car).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.car).ordered
-        expect(listener).to receive(:after_car).with(runtime, nested_list, nested_list.car).ordered
-        expect(listener).to receive(:before_cdr).with(runtime, nested_list, nested_list.cdr).ordered
-        expect(listener).to receive(:before_pair).with(runtime, nested_list.cdr).ordered
-        expect(listener).to receive(:before_car).with(runtime, nested_list.cdr, nested_list.cdr.car).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.cdr.car).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.cdr.car).ordered
-        expect(listener).to receive(:after_car).with(runtime, nested_list.cdr, nested_list.cdr.car).ordered
-        expect(listener).to receive(:before_cdr).with(runtime, nested_list.cdr, nested_list.cdr.cdr).ordered
-        expect(listener).to receive(:before_pair).with(runtime, nested_list.cdr.cdr).ordered
-        expect(listener).to receive(:before_car).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.car).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.cdr.cdr.car).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.cdr.cdr.car).ordered
-        expect(listener).to receive(:after_car).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.car).ordered
-        expect(listener).to receive(:before_cdr).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:before_empty_list).with(runtime, nested_list.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:after_empty_list).with(runtime, nested_list.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:after_cdr).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.cdr).ordered
-        expect(listener).to receive(:after_pair).with(runtime, nested_list.cdr.cdr).ordered
-        expect(listener).to receive(:after_cdr).with(runtime, nested_list.cdr, nested_list.cdr.cdr).ordered
-        expect(listener).to receive(:after_pair).with(runtime, nested_list.cdr).ordered
-        expect(listener).to receive(:after_cdr).with(runtime, nested_list, nested_list.cdr).ordered
-        expect(listener).to receive(:after_pair).with(runtime, nested_list).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[3]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[3]).ordered
-        expect(listener).to receive(:after_children).with(runtime, vec, vec.members).ordered
-        expect(listener).to receive(:after_compound_datum).with(runtime, vec).ordered
+        allow(listener).to receive(:before_simple_datum).with(runtime, nested_list.car)
+        allow(listener).to receive(:after_simple_datum).with(runtime, nested_list.car)
+        allow(listener).to receive(:after_car).with(runtime, nested_list, nested_list.car)
+        allow(listener).to receive(:before_cdr).with(runtime, nested_list, nested_list.cdr)
+        allow(listener).to receive(:before_pair).with(runtime, nested_list.cdr)
+        allow(listener).to receive(:before_car).with(runtime, nested_list.cdr, nested_list.cdr.car)
+        allow(listener).to receive(:before_simple_datum).with(runtime, nested_list.cdr.car)
+        allow(listener).to receive(:after_simple_datum).with(runtime, nested_list.cdr.car)
+        allow(listener).to receive(:after_car).with(runtime, nested_list.cdr, nested_list.cdr.car)
+        allow(listener).to receive(:before_cdr).with(runtime, nested_list.cdr, nested_list.cdr.cdr)
+        allow(listener).to receive(:before_pair).with(runtime, nested_list.cdr.cdr)
+        allow(listener).to receive(:before_car).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.car)
+        allow(listener).to receive(:before_simple_datum).with(runtime, nested_list.cdr.cdr.car)
+        allow(listener).to receive(:after_simple_datum).with(runtime, nested_list.cdr.cdr.car)
+        allow(listener).to receive(:after_car).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.car)
+        allow(listener).to receive(:before_cdr).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.cdr)
+        allow(listener).to receive(:before_empty_list).with(runtime, nested_list.cdr.cdr.cdr)
+        allow(listener).to receive(:after_empty_list).with(runtime, nested_list.cdr.cdr.cdr)
+        allow(listener).to receive(:after_cdr).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.cdr)
+        allow(listener).to receive(:after_pair).with(runtime, nested_list.cdr.cdr)
+        allow(listener).to receive(:after_cdr).with(runtime, nested_list.cdr, nested_list.cdr.cdr)
+        allow(listener).to receive(:after_pair).with(runtime, nested_list.cdr)
+        allow(listener).to receive(:after_cdr).with(runtime, nested_list, nested_list.cdr)
+        allow(listener).to receive(:after_pair).with(runtime, nested_list)
+        allow(listener).to receive(:before_simple_datum).with(runtime, vec.members[3])
+        allow(listener).to receive(:after_simple_datum).with(runtime, vec.members[3])
+        allow(listener).to receive(:after_children).with(runtime, vec, vec.members)
+        allow(listener).to receive(:after_compound_datum).with(runtime, vec)
         instance.start(runtime)
       end
     end # context
   end # describe
-end # module
+end # modulecls