skeem 0.2.16 → 0.2.20

data/lib/skeem/datum_dsl.rb

@@ -11,7 +11,7 @@ module Skeem
     def boolean(aBoolean)
       return aBoolean if aBoolean.kind_of?(SkmBoolean)
 
-      result = case aBoolean
+      case aBoolean
         when TrueClass, FalseClass
           SkmBoolean.create(aBoolean)
         when /^#t(?:rue)?|true$/
@@ -21,13 +21,12 @@ module Skeem
         else
           raise StandardError, aBoolean.inspect
       end
-      result
     end
 
     def integer(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmInteger)
 
-      result = case aLiteral
+      case aLiteral
         when Integer
           SkmInteger.create(aLiteral)
         when /^[+-]?\d+$/
@@ -35,13 +34,12 @@ module Skeem
         else
           raise StandardError, aLiteral.inspect
       end
-      result
     end
 
     def rational(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmRational)
 
-      result = case aLiteral
+      case aLiteral
         when Rational
           SkmRational.create(aLiteral)
         when /^[+-]?\d+\/\d+$/
@@ -49,13 +47,12 @@ module Skeem
         else
           raise StandardError, aLiteral.inspect
       end
-      result
     end
 
     def real(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmReal)
 
-      result = case aLiteral
+      case aLiteral
         when Numeric
           SkmReal.create(aLiteral)
         when /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
@@ -63,13 +60,12 @@ module Skeem
         else
           raise StandardError, aLiteral.inspect
       end
-      result
     end
 
     def char(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmChar)
 
-      result = case aLiteral
+      case aLiteral
         when Numeric
           SkmChar.create_from_int(aLiteral)
         when String
@@ -81,13 +77,12 @@ module Skeem
         else
           raise StandardError, aLiteral.inspect
       end
-      result
     end
 
     def string(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmString)
 
-      result = case aLiteral
+      case aLiteral
         when String
           SkmString.create(aLiteral)
         when SkmIdentifier
@@ -95,13 +90,12 @@ module Skeem
         else
           SkmString.create(aLiteral.to_s)
       end
-      result
     end
 
     def identifier(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmIdentifier)
 
-      result = case aLiteral
+      case aLiteral
         when String
           SkmIdentifier.create(aLiteral)
         when SkmString
@@ -109,13 +103,12 @@ module Skeem
         else
           raise StandardError, aLiteral.inspect
       end
-      result
     end
 
     alias symbol identifier
 
     def list(aLiteral)
-      result = case aLiteral
+      case aLiteral
         when Array
           SkmPair.create_from_a(to_datum(aLiteral))
         when SkmPair
@@ -123,12 +116,10 @@ module Skeem
         else
           SkmPair.new(to_datum(aLiteral), SkmEmptyList.instance)
         end
-
-      result
     end
 
     def vector(aLiteral)
-      result = case aLiteral
+      case aLiteral
         when Array
           SkmVector.new(to_datum(aLiteral))
         when SkmVector
@@ -136,8 +127,6 @@ module Skeem
         else
           SkmVector.new([to_datum(aLiteral)])
         end
-
-      result
     end
 
     # Conversion from Ruby object value to Skeem datum
@@ -146,7 +135,7 @@ module Skeem
       return vector(aLiteral.members) if aLiteral.kind_of?(SkmVector)
       return aLiteral if aLiteral.kind_of?(Primitive::PrimitiveProcedure)
 
-      result = case aLiteral
+      case aLiteral
         when Array
           aLiteral.map { |elem| to_datum(elem) }
         when Integer
@@ -166,25 +155,37 @@ module Skeem
           aLiteral
         else
           raise StandardError, aLiteral.inspect
-        end
-      result
+      end
     end
 
     private
 
     def parse_literal(aLiteral)
-      if aLiteral =~ /^#t(?:rue)?|true$/
-        boolean(aLiteral)
-      elsif aLiteral =~ /^#f(?:alse)?|false$/
-        boolean(aLiteral)
-      elsif aLiteral =~ /^[+-]?\d+\/\d+$/
-        rational(aLiteral)
-      elsif aLiteral =~ /^[+-]?\d+$/
-        integer(aLiteral)
-      elsif aLiteral =~ /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
-        real(aLiteral)
-      else
-        string(aLiteral)
+      # if aLiteral =~ /^#t(?:rue)?|true$/
+        # boolean(aLiteral)
+      # elsif aLiteral =~ /^#f(?:alse)?|false$/
+        # boolean(aLiteral)
+      # elsif aLiteral =~ /^[+-]?\d+\/\d+$/
+        # rational(aLiteral)
+      # elsif aLiteral =~ /^[+-]?\d+$/
+        # integer(aLiteral)
+      # elsif aLiteral =~ /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
+        # real(aLiteral)
+      # else
+        # string(aLiteral)
+      # end
+
+      case aLiteral
+        when /^#t(?:rue)?|true$/, /^#f(?:alse)?|false$/
+          boolean(aLiteral)
+        when /^[+-]?\d+\/\d+$/
+          rational(aLiteral)
+        when /^[+-]?\d+$/
+          integer(aLiteral)
+        when /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/
+          real(aLiteral)
+        else
+          string(aLiteral)
       end
     end
   end # module

data/lib/skeem/grammar.rb

@@ -6,10 +6,10 @@ require 'rley' # Load the gem
 module Skeem
   ########################################
   # Define a grammar for Skeem
-  # Official Small Scheme grammar is available at:
+  # The official Small Scheme language grammar is available at:
   # https://bitbucket.org/cowan/r7rs/src/draft-10/rnrs/r7rs.pdf
   # Names of grammar elements are based on the R7RS documentation
-  builder = Rley::Syntax::GrammarBuilder.new do
+  builder = Rley::grammar_builder do
     # Delimiters, separators...
     add_terminals('APOSTROPHE', 'COMMA', 'COMMA_AT_SIGN')
     add_terminals('GRAVE_ACCENT', 'LPAREN', 'RPAREN')
@@ -22,7 +22,7 @@ module Skeem
 
     # Keywords...
     add_terminals('BEGIN', 'COND', 'DEFINE', 'DEFINE-SYNTAX', 'DO')
-    add_terminals('ELSE', 'IF', 'INCLUDE', 'LAMBDA', 'LET', 'LET*')
+    add_terminals('ELSE', 'IF', 'INCLUDE', 'LAMBDA', 'LET', 'LET_STAR')
     add_terminals('QUOTE', 'QUASIQUOTE', 'SET!', 'SYNTAX-RULES')
     add_terminals('UNQUOTE', 'UNQUOTE-SPLICING')
 
@@ -36,7 +36,7 @@ module Skeem
     rule('definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN').as 'definition'
     rule('definition' => 'LPAREN DEFINE LPAREN IDENTIFIER def_formals RPAREN body RPAREN').as 'alt_definition'
     rule('definition' => 'syntax_definition')
-    rule('definition' => 'LPAREN BEGIN definition_star RPAREN').as 'definitions_within_begin'
+    rule('definition' => 'LPAREN BEGIN definition* RPAREN').as 'definitions_within_begin'
     rule('expression' => 'IDENTIFIER').as 'variable_reference'
     rule 'expression' => 'literal'
     rule 'expression' => 'procedure_call'
@@ -63,143 +63,104 @@ module Skeem
     rule 'simple_datum' => 'symbol'
     rule 'compound_datum' => 'list'
     rule 'compound_datum' => 'vector'
-    rule('list' => 'LPAREN datum_star RPAREN').as 'list'
+    rule('list' => 'LPAREN datum* RPAREN').as 'list'
     rule('list' => 'LPAREN datum_plus PERIOD datum RPAREN').as 'dotted_list'
-    rule('vector' => 'VECTOR_BEGIN datum_star RPAREN').as 'vector'
+    rule('vector' => 'VECTOR_BEGIN datum* RPAREN').as 'vector'
     rule('datum_plus' => 'datum_plus datum').as 'multiple_datums'
     rule('datum_plus' => 'datum').as 'last_datum'
-    rule('datum_star' => 'datum_star datum').as 'star_default'
-    rule('datum_star' => []).as 'star_base' ## 'no_datum_yet'
     rule 'symbol' => 'IDENTIFIER'
     rule('procedure_call' => 'LPAREN operator RPAREN').as 'proc_call_nullary'
-    rule('procedure_call' => 'LPAREN operator operand_plus RPAREN').as 'proc_call_args'
-    rule('operand_plus' => 'operand_plus operand').as 'multiple_operands'
-    rule('operand_plus' => 'operand').as 'last_operand'
+    rule('procedure_call' => 'LPAREN operator operand+ RPAREN').as 'proc_call_args'
     rule 'operator' => 'expression'
     rule 'operand' => 'expression'
-    rule('def_formals' => 'identifier_star').as 'def_formals'
-    rule('def_formals' => 'identifier_star PERIOD IDENTIFIER').as 'pair_formals'
+    rule('def_formals' => 'IDENTIFIER*').as 'def_formals'
+    rule('def_formals' => 'IDENTIFIER* PERIOD IDENTIFIER').as 'pair_formals'
     rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
-    rule('formals' => 'LPAREN identifier_star RPAREN').as 'fixed_arity_formals'
+    rule('formals' => 'LPAREN IDENTIFIER* RPAREN').as 'fixed_arity_formals'
     rule('formals' => 'IDENTIFIER').as 'variadic_formals'
-    rule('formals' => 'LPAREN identifier_plus PERIOD IDENTIFIER RPAREN').as 'dotted_formals'
+    rule('formals' => 'LPAREN IDENTIFIER+ PERIOD IDENTIFIER RPAREN').as 'dotted_formals'
     rule('syntax_definition' => 'LPAREN DEFINE-SYNTAX keyword transformer_spec RPAREN').as 'syntax_definition'
-    rule('identifier_star' => 'identifier_star IDENTIFIER').as 'star_default'
-    rule('identifier_star' => []).as 'star_base' ## 'no_identifier_yet'
-    rule('identifier_plus' => 'identifier_plus IDENTIFIER').as 'multiple_identifiers'
-    rule('identifier_plus' => 'IDENTIFIER').as 'last_identifier'
-    rule('body' => 'definition_star sequence').as 'body'
-    rule('definition_star' => 'definition_star definition').as 'star_default'
-    rule('definition_star' => []).as 'star_base' ## 'no_definition_yet'
-    rule('sequence' => 'command_star expression').as 'sequence'
-    rule('command_star' => 'command_star command').as 'star_default'
-    rule('command_star' => []).as 'star_base' ## 'no_command_yet'
-    rule('conditional' => 'LPAREN IF test consequent alternate RPAREN').as 'conditional'
+    rule('body' => 'definition* sequence').as 'body'
+    rule('sequence' => 'command* expression').as 'sequence'
+    rule('conditional' => 'LPAREN IF test consequent expression? RPAREN').as 'conditional'
     rule 'test' => 'expression'
     rule 'consequent' => 'expression'
-    rule 'alternate' => 'expression'
-    rule 'alternate' => []
     rule 'number' => 'INTEGER'
     rule 'number' => 'RATIONAL'
     rule 'number' => 'REAL'
     rule('assignment' => 'LPAREN SET! IDENTIFIER expression RPAREN').as 'assignment'
-    rule('derived_expression' => 'LPAREN COND cond_clause_plus RPAREN').as 'cond_form'
-    rule('derived_expression' => 'LPAREN COND cond_clause_star LPAREN ELSE sequence RPAREN RPAREN').as 'cond_else_form'
-    rule('derived_expression' => 'LPAREN LET LPAREN binding_spec_star RPAREN body RPAREN').as 'short_let_form'
+    rule('derived_expression' => 'LPAREN COND cond_clause+ RPAREN').as 'cond_form'
+    rule('derived_expression' => 'LPAREN COND cond_clause* LPAREN ELSE sequence RPAREN RPAREN').as 'cond_else_form'
+    rule('derived_expression' => 'LPAREN LET LPAREN binding_spec* RPAREN body RPAREN').as 'short_let_form'
     # TODO: implement "named let"
-    rule('derived_expression' => 'LPAREN LET IDENTIFIER LPAREN binding_spec_star RPAREN body RPAREN') # .as 'named_form'
-    rule('derived_expression' => 'LPAREN LET* LPAREN binding_spec_star RPAREN body RPAREN').as 'let_star_form'
+    rule('derived_expression' => 'LPAREN LET IDENTIFIER LPAREN binding_spec* RPAREN body RPAREN') # .as 'named_form'
+    rule('derived_expression' => 'LPAREN LET_STAR LPAREN binding_spec* RPAREN body RPAREN').as 'let_star_form'
 
     # As the R7RS grammar is too restrictive,
     # the next rule was made more general than its standard counterpart
     rule('derived_expression' => 'LPAREN BEGIN body RPAREN').as 'begin_expression'
     do_syntax = <<-END_SYNTAX
-    LPAREN DO LPAREN iteration_spec_star RPAREN
+    LPAREN DO LPAREN iteration_spec* RPAREN
       LPAREN test do_result RPAREN
-      command_star RPAREN
+      rep_command_star RPAREN
 END_SYNTAX
     rule('derived_expression' => do_syntax).as 'do_expression'
     rule 'derived_expression' => 'quasiquotation'
-    rule('cond_clause_plus' => 'cond_clause_plus cond_clause').as 'multiple_cond_clauses'
-    rule('cond_clause_plus' => 'cond_clause').as 'last_cond_clauses'
-    rule('cond_clause_star' => 'cond_clause_star cond_clause').as 'star_default'
-    rule('cond_clause_star' => []).as 'star_base' ## 'last_cond_clauses_star'
     rule('cond_clause' => 'LPAREN test sequence RPAREN').as 'cond_clause'
     rule('cond_clause' => 'LPAREN test RPAREN')
     rule('cond_clause' => 'LPAREN test ARROW recipient RPAREN').as 'cond_arrow_clause'
     rule('recipient' => 'expression')
     rule('quasiquotation' => 'LPAREN QUASIQUOTE qq_template RPAREN').as 'quasiquotation'
     rule('quasiquotation' => 'GRAVE_ACCENT qq_template').as 'quasiquotation_short'
-    rule('binding_spec_star' => 'binding_spec_star binding_spec').as 'star_default'
-    rule('binding_spec_star' => []).as 'star_base' ## 'no_binding_spec_yet'
     rule('binding_spec' => 'LPAREN IDENTIFIER expression RPAREN').as 'binding_spec'
-    rule('iteration_spec_star' => 'iteration_spec_star iteration_spec').as 'star_default'
-    rule('iteration_spec_star' => []).as 'star_base' ## 'no_iter_spec_yet'
     rule('iteration_spec' => 'LPAREN IDENTIFIER init step RPAREN').as 'iteration_spec_long'
     rule('iteration_spec' => 'LPAREN IDENTIFIER init RPAREN').as 'iteration_spec_short'
     rule('init' => 'expression')
     rule('step' => 'expression')
-    rule 'do_result' => 'sequence'
-    rule('do_result' => []).as 'star_base' ## 'empty_do_result'
+    rule('do_result' => 'sequence?').tag 'do_result'
     rule('keyword' => 'IDENTIFIER')
-    rule('includer' => 'LPAREN INCLUDE string_plus RPAREN').as 'include'
-    rule('string_plus' => 'string_plus STRING_LIT').as 'multiple_string'
-    rule('string_plus' => 'STRING_LIT').as 'last_single_string'
+    rule('includer' => 'LPAREN INCLUDE STRING_LIT+ RPAREN').as 'include'
     rule 'qq_template' => 'simple_datum'
     rule 'qq_template' => 'list_qq_template'
     rule 'qq_template' => 'vector_qq_template'
     rule 'qq_template' => 'unquotation'
-    rule('list_qq_template' => 'LPAREN qq_template_or_splice_star RPAREN').as 'list_qq'
-    rule 'list_qq_template' => 'LPAREN qq_template_or_splice_plus PERIOD qq_template RPAREN'
+    rule('list_qq_template' => 'LPAREN qq_template_or_splice* RPAREN').as 'list_qq'
+    rule 'list_qq_template' => 'LPAREN qq_template_or_splice+ PERIOD qq_template RPAREN'
     rule 'list_qq_template' => 'GRAVE_ACCENT qq_template'
-    rule('vector_qq_template' => 'VECTOR_BEGIN qq_template_or_splice_star RPAREN').as 'vector_qq'
+    rule('vector_qq_template' => 'VECTOR_BEGIN qq_template_or_splice* RPAREN').as 'vector_qq'
     rule('unquotation' => 'COMMA qq_template').as 'unquotation_short'
     rule 'unquotation' => 'LPAREN UNQUOTE qq_template RPAREN'
-    rule('qq_template_or_splice_star' => 'qq_template_or_splice_star qq_template_or_splice').as 'star_default'
-    rule('qq_template_or_splice_star' => []).as 'star_base' ## 'no_template_splice_yet'
-    rule 'qq_template_or_splice_plus' => 'qq_template_or_splice_plus qq_template_or_splice'
-    rule 'qq_template_or_splice_plus' => 'qq_template_or_splice'
     rule 'qq_template_or_splice' => 'qq_template'
     rule 'qq_template_or_splice' => 'splicing_unquotation'
     rule 'splicing_unquotation' => 'COMMA_AT_SIGN qq_template'
     rule 'splicing_unquotation' => 'LPAREN UNQUOTE-SPLICING qq_template RPAREN'
-    rule('transformer_spec' => 'LPAREN SYNTAX-RULES LPAREN identifier_star RPAREN syntax_rule_star RPAREN').as 'transformer_syntax'
-    rule('transformer_spec' => 'LPAREN SYNTAX-RULES IDENTIFIER LPAREN identifier_star RPAREN syntax_rule_star RPAREN')
-    rule('syntax_rule_star' => 'syntax_rule_star syntax_rule').as 'star_default'
-    rule('syntax_rule_star' => []).as 'star_base'
+    rule('transformer_spec' => 'LPAREN SYNTAX-RULES LPAREN IDENTIFIER* RPAREN syntax_rule* RPAREN').as 'transformer_syntax'
+    rule('transformer_spec' => 'LPAREN SYNTAX-RULES IDENTIFIER LPAREN IDENTIFIER* RPAREN syntax_rule* RPAREN')
     rule('syntax_rule' => 'LPAREN pattern template RPAREN').as 'syntax_rule'
     rule('pattern' => 'pattern_identifier')
     rule('pattern' =>  'UNDERSCORE')
-    rule('pattern' =>  'LPAREN pattern_star RPAREN')
-    rule('pattern' =>  'LPAREN pattern_plus PERIOD pattern RPAREN')
-    rule('pattern' =>  'LPAREN pattern_plus ELLIPSIS pattern_star RPAREN')
-    rule('pattern' =>  'LPAREN pattern_plus ELLIPSIS pattern_star PERIOD pattern RPAREN')
-    rule('pattern' =>  'VECTOR_BEGIN pattern_star RPAREN')
-    rule('pattern' =>  'VECTOR_BEGIN pattern_plus ELLIPSIS pattern_star RPAREN')
+    rule('pattern' =>  'LPAREN pattern* RPAREN')
+    rule('pattern' =>  'LPAREN pattern+ PERIOD pattern RPAREN')
+    rule('pattern' =>  'LPAREN pattern+ ELLIPSIS pattern* RPAREN')
+    rule('pattern' =>  'LPAREN pattern+ ELLIPSIS pattern* PERIOD pattern RPAREN')
+    rule('pattern' =>  'VECTOR_BEGIN pattern* RPAREN')
+    rule('pattern' =>  'VECTOR_BEGIN pattern+ ELLIPSIS pattern* RPAREN')
     rule('pattern' =>  'pattern_datum')
-    rule('pattern_star' => 'pattern_star pattern').as 'star_default'
-    rule('pattern_star' => []).as 'star_base'
-    rule('pattern_plus' => 'pattern_plus pattern')
-    rule('pattern_plus' => 'pattern')
     rule('pattern_datum' => 'STRING_LIT')
     rule('pattern_datum' => 'CHAR')
     rule('pattern_datum' => 'BOOLEAN')
     rule('pattern_datum' => 'number')
     # rule('pattern_datum' => 'bytevector')
     rule('template' => 'pattern_identifier')
-    rule('template' => 'LPAREN template_element_star RPAREN')
-    rule('template' => 'LPAREN template_element_plus PERIOD template RPAREN')
-    rule('template' =>  'VECTOR_BEGIN template_element_star RPAREN')
+    rule('template' => 'LPAREN template_element* RPAREN')
+    rule('template' => 'LPAREN template_element+ PERIOD template RPAREN')
+    rule('template' =>  'VECTOR_BEGIN template_element* RPAREN')
     rule('template' =>  'template_datum')
-    rule('template_element_star' => 'template_element_star template_element').as 'star_default'
-    rule('template_element_star' => []).as 'star_base'
-    rule('template_element_plus' => 'template_element_plus template_element')
-    rule('template_element_plus' => 'template_element')
     rule('template_element' =>  'template')
     rule('template_element' =>  'template ELLIPSIS')
     rule('template_datum' =>  'pattern_datum')
     rule('pattern_identifier' => 'IDENTIFIER')
-    # Ugly: specailized production rule per keyword...
+    # Ugly: specialized production rule per keyword...
     rule('pattern_identifier' => 'BEGIN')
     rule('pattern_identifier' => 'COND')
     rule('pattern_identifier' => 'DEFINE')

data/lib/skeem/interpreter.rb

@@ -8,7 +8,11 @@ require_relative './primitive/primitive_builder'
 module Skeem
   class Interpreter
     include Primitive::PrimitiveBuilder
+
+    # @return [Skeem::Parser] Link to Skeem parser
     attr_reader(:parser)
+
+    # @return [Skeem::Runtime] Link to runtime object (holds call stack & frames)
     attr_reader(:runtime)
 
     def initialize
@@ -27,11 +31,11 @@ module Skeem
       add_standard(runtime)
     end
 
-    def parse(source, mode = nil)
+    def parse(source, _mode = nil)
       @parser ||= Parser.new
       @ptree = parser.parse(source)
-      # $stderr.puts @ptree.root.inspect if mode.nil?
-      # require 'debug' unless mode.nil?
+      # $stderr.puts @ptree.root.inspect if _mode.nil?
+      # require 'debug' unless _mode.nil?
     end
 
     def run(source, mode = nil)
@@ -45,7 +49,7 @@ module Skeem
     end
 
     def add_standard(_runtime)
-      std_pathname = File.dirname(__FILE__) + '/standard/base.skm'
+      std_pathname = "#{File.dirname(__FILE__)}/standard/base.skm"
       load_lib(std_pathname)
     end
 

data/lib/skeem/primitive/primitive_builder.rb

@@ -234,23 +234,17 @@ module Skeem
           if arglist.empty?
             raw_result = reciprocal(raw_result)
           else
-            # Ugly: Ruby version dependency: Rubies older than 2.4 have class Fixnum instead of Integer
-            int_class = (RUBY_VERSION[0..2] < '2.4') ? Fixnum : Integer
-
             arglist.each do |elem|
               elem_value = elem.value
               case [raw_result.class, elem_value.class]
-                when [int_class, int_class]
+                when [Integer, Integer]
                   if raw_result.modulo(elem_value).zero?
                     raw_result /= elem_value
                   else
                     raw_result = Rational(raw_result, elem_value)
                   end
 
-                when [int_class, Rational]
-                  raw_result *= reciprocal(elem_value)
-
-                when [Rational, Rational]
+                when [Integer, Rational], [Rational, Rational]
                   raw_result *= reciprocal(elem_value)
                 else
                   raw_result = raw_result.to_f
@@ -827,8 +821,6 @@ module Skeem
                 cloned = arg.klone
                 if result.kind_of?(SkmEmptyList)
                   result = cloned
-                elsif result.kind_of?(SkmEmptyList)
-                  result = SkmPair.new(arg, SkmEmptyList.instance)
                 else
                   result.append_list(cloned)
                 end
@@ -945,7 +937,7 @@ module Skeem
                 break
               end
               pair = pair.cdr
-              break unless pair&.kind_of?(SkmPair)
+              break unless pair.kind_of?(SkmPair)
             end
           end
 
@@ -967,7 +959,7 @@ module Skeem
                 break
               end
               pair = pair.cdr
-              break unless pair&.kind_of?(SkmPair)
+              break unless pair.kind_of?(SkmPair)
             end
           end
 
@@ -1142,7 +1134,7 @@ module Skeem
             # Error: assertion failed: (> 1 2)
             msg1 = "assertion failed on line #{pos.line}, column #{pos.column}"
             msg2 = ", with #{arg_evaluated.inspect}"
-            raise StandardError, 'Error: ' + msg1 + msg2
+            raise StandardError, "Error: #{msg1}#{msg2}"
           else
             boolean(true)
           end
@@ -1165,7 +1157,7 @@ module Skeem
       # Non-standard procedure reserved for internal testing/debugging purposes.
       def create_inspect(aRuntime)
         primitive = lambda do |_runtime, arg_evaluated|
-          $stderr.puts 'INSPECT>' + arg_evaluated.inspect
+          $stderr.puts "INSPECT>#{arg_evaluated.inspect}"
           Skeem::SkmUndefined.instance
         end
         define_primitive_proc(aRuntime, '_inspect', unary, primitive)
@@ -1233,7 +1225,7 @@ module Skeem
         else
           msg2 = "but got #{argument.class}"
         end
-        raise StandardError, msg1 + ' ' + msg2
+        raise StandardError, "#{msg1} #{msg2}"
       end
 
       def remaining_args(arglist, aRuntime)

data/lib/skeem/primitive/primitive_procedure.rb

@@ -5,8 +5,13 @@ require_relative '../s_expr_nodes'
 module Skeem
   module Primitive
     class PrimitiveProcedure
+      # @return [Skeem::SkmIdentifier] 'name' of the procedure
       attr_reader(:identifier)
+
+      # @return [Skeem::Arity] number of arguments of the procedure
       attr_reader(:arity)
+
+      # @return [Proc] A Ruby lambda that implements the primitive procedure
       attr_reader(:code)
 
       # param [anArity] Arity of the lambda code (ignoring the runtime object)
@@ -42,10 +47,11 @@ module Skeem
         check_actual_count(actuals)
         # TODO: check that next line became useless
         # aProcedureCall.operands_consumed = true
-        result = do_call(aRuntime, actuals)
+        # result = do_call(aRuntime, actuals)
         # $stderr.puts "  Result: #{result.inspect}"
         # $stderr.puts "--- End of procedure #{identifier}"
-        result
+        # result
+        do_call(aRuntime, actuals)
       end
 
       def skm_equal?(other)
@@ -146,20 +152,20 @@ module Skeem
 
       def error_lambda(message_suffix)
         msg1 = "Primitive procedure '#{identifier.value}'"
-        raise StandardError, msg1 + ' ' + message_suffix
+        raise StandardError, "#{msg1} #{message_suffix}"
       end
 
       def discrepancy_arity_argument_count(arity_required, count_param, delta)
         msg1 = "Discrepancy in primitive procedure '#{identifier.value}'"
         msg2 = "between arity (#{arity_required}) + #{delta}"
         msg3 = "and parameter count of lambda #{count_param}."
-        raise StandardError, msg1 + ' ' + msg2 + ' ' + msg3
+        raise StandardError, "#{msg1} #{msg2} #{msg3}"
       end
 
       def wrong_number_arguments(required, actual)
         msg1 = "Wrong number of arguments for #<Procedure #{identifier.value}>"
         msg2 = "(required at least #{required}, got #{actual})"
-        raise StandardError, msg1 + ' ' + msg2
+        raise StandardError, "#{msg1} #{msg2}"
       end
     end # class
   end # module

data/lib/skeem/runtime.rb

@@ -124,16 +124,14 @@ module Skeem
     private
 
     def normalize_key(aKey)
-      result = case aKey
-                 when String
-                   aKey
-                 when SkmVariableReference
-                    aKey.child.value
-                 else
-                   aKey.evaluate(self).value
-               end
-
-      result
+      case aKey
+        when String
+          aKey
+        when SkmVariableReference
+          aKey.child.value
+        else
+          aKey.evaluate(self).value
+      end
     end
   end # class
 end # module