skeem 0.2.15 → 0.2.19

data/.travis.yml

@@ -0,0 +1,27 @@
+language: ruby
+dist: trusty
+
+before_install:
+  - gem update --system
+  - gem install bundler  
+
+script:
+  - bundle exec rake
+  
+rvm:
+  - 2.6.3
+  - 2.5.5
+  - 2.4.6
+  - 2.3.8
+  - jruby-9.1.9.0
+  
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+
+# whitelist
+branches:
+  only:
+    - master

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## [0.2.19] - 2021-08-30
+- Grammar refactoring: use ?, * and + modifiers in Rley 0.8.03 rules
+
+### Changed
+- File `grammar.rb`: Remove redundant rules after introduction og ?, * and + modifiers
+- Class `SkmBuilder`: Removal of useless methods after removal of their rule counterpart
+
+
+
+## [0.2.18] - 2021-08-29
+- Minor refactoring for Rley 0.8.03
+- Code restyling to please rubocop 1.19.1.
+
+### Changed
+- File `.rubocop.yml` updated with newer Rubocop cops
+- File `grammar.rb`: Calling `Rley::grammar_builder`, replace `LET*` token by `LET_STAR`
+- Other files changed to get rid of Rubocop offences
+
+## [0.2.17] - 2020-05-09
+- Updated `.rubocop.yml` file. 
+- Code restyling to please rubocop 0.8.0. 
+
+## [0.2.16] - 2019-08-18
+- Code refactoring to use string frozen magic comments (as a consequence, srl_ruby runs only on Rubies 2.3 or newer).  
+- Code restyling to please rubocop 0.7.40. 
+
 ## [0.2.15] - 2019-07-02
 - Added a basic command-line and console interface for Skeem interpreter.
 - Added procedures: `display!`, `newline`, `make-list`

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }

data/README.md

@@ -32,7 +32,8 @@ If you're not familiar to Scheme, the section [About Scheme](#about-scheme) cont
 
 ## Usage
 Once the gem is installed, the `skeem` executable can be used.
-It allows to run the interpreter from the command line.
+It allows to run the interpreter from a REPL console or from the command line.
+Another way to interact with the Skeem interpreter is to embed it in your Ruby code.
 
 ### Launching a REPL session
 To start a REPL (Read-Eval-Print-Loop) session, just type:
@@ -42,7 +43,7 @@ To start a REPL (Read-Eval-Print-Loop) session, just type:
 
 Skeem displays a greeting, a prompt and then waits for your input:
 ```
-Welcome to Skeem 0.2.15.
+Welcome to Skeem 0.2.16.
 >
 ```
 

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 

data/appveyor.yml

@@ -1,17 +1,16 @@
 version: '{build}'
-max_jobs: 3
+max_jobs: 5
 environment:
   matrix:
+  - Ruby_version: 26-x64  
   - Ruby_version: 25-x64
   - Ruby_version: 24-x64
   - Ruby_version: 23-x64
+  - Ruby_version: 26  
   - Ruby_version: 25
   - Ruby_version: 24
   - Ruby_version: 23
 
-# These are failing
-#  - Ruby_version: 26
-#  - Ruby_version: 26-x64
 
 install:
   - set PATH=C:\Ruby%Ruby_version%\bin;%PATH%

data/bin/skeem

@@ -1,20 +1,22 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'skeem'
 
 class SkeemREPL
   attr_reader :interpreter
 
-  def initialize()
+  def initialize
     @interpreter = Skeem::Interpreter.new
   end
 
   def run_session
-    puts "Welcome to Skeem #{Skeem::VERSION}."  
+    puts "Welcome to Skeem #{Skeem::VERSION}."
     loop do
       print '> '
       input = gets.chomp.strip
-      break if input == '(quit)' || input == '(exit)'
+      break if %w[(quit) (exit)].include?(input)
+
       process_input(input)
     end
   end
@@ -22,15 +24,13 @@ class SkeemREPL
   def run_file(aFilename)
     if File.exist?(aFilename)
       valid_fname = aFilename
-    else # Retry by adding extension...
-      if File.extname(aFilename).empty?
-        if File.exist?(aFilename + '.skm')
-          valid_fname = aFilename + '.skm'
-        elsif File.exist?(aFilename + '.scm')
-          valid_fname = aFilename + '.scm'
-        else
-          valid_fname = nil
-        end
+    elsif File.extname(aFilename).empty? # Retry by adding extension...
+      if File.exist?("#{aFilename}.skm")
+        valid_fname = "#{aFilename}.skm"
+      elsif File.exist?("#{aFilename}.scm")
+        valid_fname = "#{aFilename}.scm"
+      else
+        valid_fname = nil
       end
     end
 
@@ -43,8 +43,8 @@ class SkeemREPL
   def process_input(input)
     begin
       ptree = interpreter.parse(input)
-    rescue StandardError => exc
-      $stderr.puts exc.message
+    rescue StandardError => e
+      $stderr.puts e.message
       return
     end
 
@@ -69,4 +69,4 @@ if ARGV.empty?
   djinn.run_session
 else
   djinn.run_file(ARGV[0])
-end
+end

data/lib/skeem/datum_dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'skm_simple_datum'
 require_relative 'skm_compound_datum'
 require_relative 'skm_pair'
@@ -9,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$/
@@ -24,7 +26,7 @@ module Skeem
     def integer(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmInteger)
 
-      result = case aLiteral
+      case aLiteral
         when Integer
           SkmInteger.create(aLiteral)
         when /^[+-]?\d+$/
@@ -37,7 +39,7 @@ module Skeem
     def rational(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmRational)
 
-      result = case aLiteral
+      case aLiteral
         when Rational
           SkmRational.create(aLiteral)
         when /^[+-]?\d+\/\d+$/
@@ -50,7 +52,7 @@ module Skeem
     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,7 +65,7 @@ module Skeem
     def char(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmChar)
 
-      result = case aLiteral
+      case aLiteral
         when Numeric
           SkmChar.create_from_int(aLiteral)
         when String
@@ -80,7 +82,7 @@ module Skeem
     def string(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmString)
 
-      result = case aLiteral
+      case aLiteral
         when String
           SkmString.create(aLiteral)
         when SkmIdentifier
@@ -93,7 +95,7 @@ module Skeem
     def identifier(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmIdentifier)
 
-      result = case aLiteral
+      case aLiteral
         when String
           SkmIdentifier.create(aLiteral)
         when SkmString
@@ -106,7 +108,7 @@ module Skeem
     alias symbol identifier
 
     def list(aLiteral)
-      result = case aLiteral
+      case aLiteral
         when Array
           SkmPair.create_from_a(to_datum(aLiteral))
         when SkmPair
@@ -114,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
@@ -127,8 +127,6 @@ module Skeem
         else
           SkmVector.new([to_datum(aLiteral)])
         end
-
-      result
     end
 
     # Conversion from Ruby object value to Skeem datum
@@ -137,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
@@ -150,33 +148,45 @@ module Skeem
           SkmBoolean.create(aLiteral)
         when String
           parse_literal(aLiteral)
-        when SkmPair  # Special case: not a PORO literal
+        when SkmPair # Special case: not a PORO literal
           # One assumes that a Skeem list contains only Skeem datum objects
           SkmPair.create_from_a(aLiteral.to_a)
         when SkmUndefined
           aLiteral
         else
           raise StandardError, aLiteral.inspect
-        end
+      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
-end # module
+end # module

data/lib/skeem/element_visitor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Skeem
   class SkmElementVisitor
     # Link to the root element to visit
@@ -12,6 +14,7 @@ module Skeem
     # @param aRoot [SkmElement] the parse tree to visit.
     def initialize(aRoot)
       raise StandardError if aRoot.nil?
+
       @root = aRoot
       @subscribers = []
     end
@@ -57,7 +60,6 @@ module Skeem
       broadcast(:after_empty_list, anEmptyList)
     end
 
-
     def visit_pair(aPair)
       broadcast(:before_pair, aPair)
       traverse_car_cdr(aPair)
@@ -110,8 +112,9 @@ module Skeem
     def broadcast(msg, *args)
       subscribers.each do |subscr|
         next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+
         subscr.send(msg, runtime, *args)
       end
     end
   end # class
-end # module
+end # module

data/lib/skeem/grammar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Grammar for Skeem (a subset of Scheme language)
 require 'rley' # Load the gem
 
@@ -7,11 +9,11 @@ module Skeem
   # Official Small Scheme 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')
-    add_terminals('PERIOD', 'ARROW')
+    add_terminals('PERIOD', 'UNDERSCORE', 'ARROW', 'ELLIPSIS')
     add_terminals('VECTOR_BEGIN')
 
     # Literal values...
@@ -19,9 +21,9 @@ module Skeem
     add_terminals('CHAR', 'STRING_LIT', 'IDENTIFIER')
 
     # Keywords...
-    add_terminals('BEGIN', 'COND', 'DEFINE', 'DO', 'ELSE')
-    add_terminals('IF', 'LAMBDA', 'LET', 'LET*')
-    add_terminals('QUOTE', 'QUASIQUOTE', 'SET!')
+    add_terminals('BEGIN', 'COND', 'DEFINE', 'DEFINE-SYNTAX', 'DO')
+    add_terminals('ELSE', 'IF', 'INCLUDE', 'LAMBDA', 'LET', 'LET_STAR')
+    add_terminals('QUOTE', 'QUASIQUOTE', 'SET!', 'SYNTAX-RULES')
     add_terminals('UNQUOTE', 'UNQUOTE-SPLICING')
 
     rule('program' => 'cmd_or_def_plus').as 'main'
@@ -33,7 +35,8 @@ module Skeem
     rule 'command' => 'expression'
     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' => 'LPAREN BEGIN definition_star RPAREN').as 'definitions_within_begin'
+    rule('definition' => 'syntax_definition')
+    rule('definition' => 'LPAREN BEGIN definition* RPAREN').as 'definitions_within_begin'
     rule('expression' => 'IDENTIFIER').as 'variable_reference'
     rule 'expression' => 'literal'
     rule 'expression' => 'procedure_call'
@@ -41,8 +44,9 @@ module Skeem
     rule 'expression' => 'conditional'
     rule 'expression' => 'assignment'
     rule 'expression' => 'derived_expression'
+    rule 'expression' => 'includer'
     rule 'literal' => 'quotation'
-    rule 'literal' => 'self-evaluating'   
+    rule 'literal' => 'self-evaluating'
     rule('quotation' => 'APOSTROPHE datum').as 'quotation_short'
     rule('quotation' => 'LPAREN QUOTE datum RPAREN').as 'quotation'
     rule 'self-evaluating' => 'BOOLEAN'
@@ -59,99 +63,118 @@ 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 'datum_star'
-    rule('datum_star' => []).as '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('identifier_star' => 'identifier_star IDENTIFIER').as 'identifier_star'
-    rule('identifier_star' => []).as '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 'definition_star'
-    rule('definition_star' => []).as 'no_definition_yet'
-    rule('sequence' => 'command_star expression').as 'sequence'
-    rule('command_star' => 'command_star command').as 'multiple_commands'
-    rule('command_star' => []).as 'no_command_yet'
-    rule('conditional' => 'LPAREN IF test consequent alternate RPAREN').as 'conditional'
+    rule('formals' => 'LPAREN IDENTIFIER+ PERIOD IDENTIFIER RPAREN').as 'dotted_formals'
+    rule('syntax_definition' => 'LPAREN DEFINE-SYNTAX keyword transformer_spec RPAREN').as 'syntax_definition'
+    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 LET* LPAREN binding_spec_star RPAREN body RPAREN').as 'let_star_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* 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, 
+    # 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
 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 'cond_clauses_star'
-    rule('cond_clause_star' => []).as '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 'multiple_binding_specs'
-    rule('binding_spec_star' => []).as 'no_binding_spec_yet'
     rule('binding_spec' => 'LPAREN IDENTIFIER expression RPAREN').as 'binding_spec'
-    rule('iteration_spec_star' => 'iteration_spec_star iteration_spec').as 'multiple_iter_specs'
-    rule('iteration_spec_star' => []).as '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 'empty_do_result'
+    rule 'do_result' => 'sequence?'
+    rule('keyword' => 'IDENTIFIER')
+    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 'multiple_template_splice'
-    rule('qq_template_or_splice_star' => []).as '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* 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* 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_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* RPAREN')
+    rule('template' => 'LPAREN template_element+ PERIOD template RPAREN')
+    rule('template' =>  'VECTOR_BEGIN template_element* RPAREN')
+    rule('template' =>  'template_datum')
+    rule('template_element' =>  'template')
+    rule('template_element' =>  'template ELLIPSIS')
+    rule('template_datum' =>  'pattern_datum')
+    rule('pattern_identifier' => 'IDENTIFIER')
+    # Ugly: specialized production rule per keyword...
+    rule('pattern_identifier' => 'BEGIN')
+    rule('pattern_identifier' => 'COND')
+    rule('pattern_identifier' => 'DEFINE')
+    rule('pattern_identifier' => 'ELSE')
+    rule('pattern_identifier' => 'IF')
+    rule('pattern_identifier' => 'INCLUDE')
+    rule('pattern_identifier' => 'LAMBDA')
+    rule('pattern_identifier' => 'LET')
+    rule('pattern_identifier' => 'LET*')
+    rule('pattern_identifier' => 'QUOTE')
+    rule('pattern_identifier' => 'QUASIQUOTE')
+    rule('pattern_identifier' => 'SET!')
+    rule('pattern_identifier' => 'UNQUOTE')
+    rule('pattern_identifier' => 'UNQUOTE-SPLICING')
   end
 
   # And now build the grammar and make it accessible via a global constant