dendroid 0.1.00 → 0.2.01

data/spec/dendroid/recognizer/recognizer_spec.rb

@@ -51,7 +51,7 @@ describe Dendroid::Recognizer::Recognizer do
         'm => t . @ 0',
         's => m . @ 0',
         # 'm => m . STAR t @ 0',
-        'p => s . @ 0',
+        'p => s . @ 0', # Can be ruled out (next token != eos)
         's => s . PLUS m @ 0'
       ]
       set2 = [ # 2 + . 3 * 4'
@@ -65,7 +65,7 @@ describe Dendroid::Recognizer::Recognizer do
         'm => t . @ 2',
         's => s PLUS m . @ 0',
         'm => m . STAR t @ 2',
-        'p => s . @ 0'
+        'p => s . @ 0' # Can be ruled out (next token != eos)
         # 's => s . PLUS m @ 0'
       ]
       set4 = [ # 2 + 3 * . 4'
@@ -422,6 +422,54 @@ describe Dendroid::Recognizer::Recognizer do
       comp_expected_actuals(chart, expectations)
     end
 
+    it 'accepts an input with multiple levels of ambiguity' do
+      recognizer = described_class.new(grammar_l8, tokenizer_l8)
+      chart = recognizer.run('x x x x')
+      expect(chart).to be_successful
+
+      set0 = [ # . x x x x
+        'S => . S S @ 0',
+        'S => . x @ 0'
+      ]
+      set1 = [ # x . x x x
+        'S => x . @ 0',
+        'S => S . S @ 0',
+        'S => . S S @ 1',
+        'S => . x @ 1'
+      ]
+      set2 = [ # x x . x x
+        'S => x . @ 1',
+        'S => S S . @ 0',
+        'S => S . S @ 1',
+        'S => S . S @ 0',
+        'S => . S S @ 2',
+        'S => . x @ 2'
+      ]
+      set3 = [ # x x x . x
+        'S => x . @ 2',
+        'S => S S . @ 1',
+        'S => S S . @ 0',
+        'S => S . S @ 2',
+        'S => S . S @ 1',
+        'S => S . S @ 0',
+        'S => . S S @ 3',
+        'S => . x @ 3'
+      ]
+      set4 = [ # x x x x .
+        'S => x . @ 3',
+        'S => S S . @ 2',
+        'S => S S . @ 1',
+        'S => S S . @ 0', # Success entry
+        'S => S . S @ 3',
+        'S => S . S @ 2',
+        'S => S . S @ 1',
+        'S => S . S @ 0',
+        'S => . S S @ 4'
+      ]
+      expectations = [set0, set1, set2, set3, set4]
+      comp_expected_actuals(chart, expectations)
+    end
+
     it 'swallows the input from an infinite ambiguity grammar' do
       recognizer = described_class.new(grammar_l9, tokenizer_l9)
       chart = recognizer.run('x x x')
@@ -441,7 +489,8 @@ describe Dendroid::Recognizer::Recognizer do
         'S => . S S @ 1',
         'S => . @ 1',
         'S => . x @ 1',
-        'S => S . S @ 1'
+        'S => S . S @ 1',
+        'S => S S . @ 1'
       ]
       set2 = [ # x x . x
         'S => x . @ 1',
@@ -452,7 +501,8 @@ describe Dendroid::Recognizer::Recognizer do
         'S => . S S @ 2',
         'S => . @ 2',
         'S => . x @ 2',
-        'S => S . S @ 2'
+        'S => S . S @ 2',
+        'S => S S . @ 2'
       ]
       set3 = [ # x x x .
         'S => x . @ 2',
@@ -465,7 +515,8 @@ describe Dendroid::Recognizer::Recognizer do
         'S => . S S @ 3',
         'S => . @ 3',
         # 'S => . x @ 3',
-        'S => S . S @ 3'
+        'S => S . S @ 3',
+        'S => S S . @ 3'
       ]
       expectations = [set0, set1, set2, set3]
       comp_expected_actuals(chart, expectations)

data/spec/dendroid/support/sample_grammars.rb

@@ -211,6 +211,7 @@ module SampleGrammars
   end
 
   def grammar_l10
+    # Grammar with left recursive rule
     builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
       declare_terminals('a')
 
@@ -230,6 +231,7 @@ module SampleGrammars
 
   def grammar_l11
     builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
+      # Grammar with right-recursive rule
       declare_terminals('a')
 
       rule 'A' => ['a A', '']
@@ -254,9 +256,7 @@ module SampleGrammars
       declare_terminals('a', 'b')
 
       rule 'S' => ['A T', 'a T']
-      # rule 'S' => 'a T'
       rule 'A' => ['a', 'B A']
-      # rule 'A' => 'B A'
       rule 'B' => ''
       rule 'T' => 'b b b'
     end

data/spec/dendroid/syntax/grammar_spec.rb

@@ -4,8 +4,7 @@ require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
 require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\production'
-require_relative '..\..\..\lib\dendroid\syntax\choice'
+require_relative '..\..\..\lib\dendroid\syntax\rule'
 require_relative '..\..\..\lib\dendroid\syntax\grammar'
 require_relative '..\..\..\lib\dendroid\grm_dsl\base_grm_builder'
 
@@ -33,19 +32,15 @@ describe Dendroid::Syntax::Grammar do
     Dendroid::Syntax::SymbolSeq.new(symbols)
   end
 
-  def build_production(lhs, symbols)
-    Dendroid::Syntax::Production.new(lhs, build_symbol_seq(symbols))
-  end
-
   def build_choice(lhs, sequences)
-    Dendroid::Syntax::Choice.new(lhs, sequences.map { |arr| build_symbol_seq(arr) })
+    Dendroid::Syntax::Rule.new(lhs, sequences.map { |arr| build_symbol_seq(arr) })
   end
 
   def build_all_rules
-    rule1 = build_production(p_symb, [s_symb]) # p => s
+    rule1 = build_choice(p_symb, [[s_symb]]) # p => s
     rule2 = build_choice(s_symb, [[s_symb, plus_symb, m_symb], [m_symb]]) # s => s + m | m
     rule3 = build_choice(m_symb, [[m_symb, star_symb, t_symb], [t_symb]]) # m => m * t
-    rule4 = build_production(t_symb, [int_symb]) # t => INTEGER
+    rule4 = build_choice(t_symb, [[int_symb]]) # t => INTEGER
     [rule1, rule2, rule3, rule4]
   end
 
@@ -72,7 +67,7 @@ describe Dendroid::Syntax::Grammar do
 
   context 'Adding productions:' do
     it 'allows the addition of one production rule' do
-      rule = build_production(p_symb, [s_symb])
+      rule = build_choice(p_symb, [[s_symb]])
       expect { subject.add_rule(rule) }.not_to raise_error
       expect(subject.rules.size).to eq(1)
       expect(subject.rules.first).to eq(rule)
@@ -141,10 +136,10 @@ describe Dendroid::Syntax::Grammar do
       nterm_e = build_nonterminal('E')
 
       instance = described_class.new([terminal_a])
-      instance.add_rule(build_production(nterm_s_prime, [nterm_s]))
-      instance.add_rule(build_production(nterm_s, [nterm_a, nterm_a, nterm_a, nterm_a]))
+      instance.add_rule(build_choice(nterm_s_prime, [[nterm_s]]))
+      instance.add_rule(build_choice(nterm_s, [[nterm_a, nterm_a, nterm_a, nterm_a]]))
       instance.add_rule(build_choice(nterm_a, [[terminal_a], [nterm_e]]))
-      instance.add_rule(build_production(nterm_e, []))
+      instance.add_rule(build_choice(nterm_e, [[]]))
 
       instance.complete!
       all_nonterminals = subject.symbols.reject(&:terminal?)
@@ -160,7 +155,7 @@ describe Dendroid::Syntax::Grammar do
       # Let add's unreachable symbols
       zed_symb = build_nonterminal('Z')
       question_symb = build_nonterminal('?')
-      bad_rule = build_production(zed_symb, [zed_symb, question_symb, int_symb]) # Z => Z ? INTEGER
+      bad_rule = build_choice(zed_symb, [[zed_symb, question_symb, int_symb]]) # Z => Z ? INTEGER
       subject.add_rule(bad_rule)
       unreachable = subject.send(:unreachable_symbols)
       expect(unreachable).not_to be_empty
@@ -175,7 +170,7 @@ describe Dendroid::Syntax::Grammar do
       expect(t_symb).to be_productive
       expect(p_symb).to be_productive
 
-      # Grammar with non-productive symbols
+      # # Grammar with non-productive symbols
       term_a = build_terminal('a')
       term_b = build_terminal('b')
       term_c = build_terminal('c')
@@ -191,12 +186,12 @@ describe Dendroid::Syntax::Grammar do
       nterm_S = build_nonterminal('S')
       instance = described_class.new([term_a, term_b, term_c, term_d, term_e, term_f])
       instance.add_rule(build_choice(nterm_S, [[nterm_A, nterm_B], [nterm_D, nterm_E]]))
-      instance.add_rule(build_production(nterm_A, [term_a]))
-      instance.add_rule(build_production(nterm_B, [term_b, nterm_C]))
-      instance.add_rule(build_production(nterm_C, [term_c]))
-      instance.add_rule(build_production(nterm_D, [term_d, nterm_F]))
-      instance.add_rule(build_production(nterm_E, [term_e]))
-      instance.add_rule(build_production(nterm_F, [term_f, nterm_D]))
+      instance.add_rule(build_choice(nterm_A, [[term_a]]))
+      instance.add_rule(build_choice(nterm_B, [[term_b, nterm_C]]))
+      instance.add_rule(build_choice(nterm_C, [[term_c]]))
+      instance.add_rule(build_choice(nterm_D, [[term_d, nterm_F]]))
+      instance.add_rule(build_choice(nterm_E, [[term_e]]))
+      instance.add_rule(build_choice(nterm_F, [[term_f, nterm_D]]))
       nonproductive = instance.send(:mark_non_productive_symbols)
       expect(nonproductive).not_to be_empty
       expect(nonproductive).to eq([nterm_D, nterm_F])

data/spec/dendroid/syntax/rule_spec.rb

@@ -3,28 +3,77 @@
 require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
+require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
 require_relative '..\..\..\lib\dendroid\syntax\rule'
 
 describe Dendroid::Syntax::Rule do
   let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
+  let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
+  let(:minus_symb) { Dendroid::Syntax::Terminal.new('MINUS') }
   let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
+  let(:foo_symb) { Dendroid::Syntax::NonTerminal.new('foo') }
+  let(:alt1) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
+  let(:alt2) { Dendroid::Syntax::SymbolSeq.new([num_symb, minus_symb, num_symb]) }
+  let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
 
-  subject { described_class.new(expr_symb) }
+  # Implements a choice rule:
+  #   expression => NUMBER PLUS NUMBER
+  #              |  NUMBER MINUS NUMBER
+  #              |  epsilon
+  subject { described_class.new(expr_symb, [alt1, alt2, empty_body]) }
 
   context 'Initialization:' do
-    it 'is initialized with a non-terminal' do
-      expect { described_class.new(expr_symb) }.not_to raise_error
+    it 'is initialized with a head and alternatives' do
+      expect { described_class.new(expr_symb, [alt1, alt2, empty_body]) }.not_to raise_error
     end
 
     it 'knows its head (aka lhs)' do
       expect(subject.head).to eq(expr_symb)
     end
+
+    it 'knows its alternatives' do
+      expect(subject.alternatives).to eq([alt1, alt2, empty_body])
+    end
+
+    it 'renders a String representation of itself' do
+      expectation = 'expression => NUMBER PLUS NUMBER | NUMBER MINUS NUMBER | '
+      expect(subject.to_s).to eq(expectation)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'knows its terminal members' do
+      expect(subject.terminals).to eq([num_symb, plus_symb, minus_symb])
+    end
+
+    it 'knows its non-terminal members' do
+      expect(subject.nonterminals).to be_empty
+
+      my_alt1 = Dendroid::Syntax::SymbolSeq.new([expr_symb, plus_symb, expr_symb])
+      my_alt2 = Dendroid::Syntax::SymbolSeq.new([foo_symb, minus_symb, expr_symb])
+      instance = described_class.new(foo_symb, [my_alt1, my_alt2])
+      expect(instance.nonterminals).to eq([expr_symb, foo_symb])
+    end
   end # context
 
   context 'Errors:' do
-    it 'fails when initialized with a terminal' do
-      msg = "Terminal symbol 'NUMBER' may not be on left-side of a rule."
-      expect { described_class.new(num_symb) }.to raise_error(StandardError, msg)
+    context 'Errors:' do
+      it 'fails when initialized with a terminal' do
+        msg = "Terminal symbol 'NUMBER' may not be on left-side of a rule."
+        expect { described_class.new(num_symb, []) }.to raise_error(StandardError, msg)
+      end
+    end
+
+    it 'fails when initialized with one alternative only' do
+      err = StandardError
+      err_msg = 'The choice for `expression` must have at least one alternative.'
+      expect { described_class.new(expr_symb, []) }.to raise_error(err, err_msg)
     end
-  end
+
+    it 'fails in presence of duplicate rhs' do
+      err = StandardError
+      err_msg = 'Duplicate alternatives: expression => NUMBER PLUS NUMBER'
+      expect { described_class.new(expr_symb, [alt1, alt2, alt1]) }.to raise_error(err, err_msg)
+    end
+  end # context
 end # describe

data/version.txt

@@ -1 +1 @@
-0.1.00
+0.2.01

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.1.00
+  version: 0.2.01
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-03 00:00:00.000000000 Z
+date: 2023-12-17 00:00:00.000000000 Z
 dependencies: []
 description: WIP. A Ruby implementation of an Earley parser
 email: famished.tiger@yahoo.com
@@ -24,47 +24,54 @@ files:
 - bin/dendroid
 - dendroid.gemspec
 - lib/dendroid.rb
-- lib/dendroid/grm_analysis/alternative_item.rb
-- lib/dendroid/grm_analysis/choice_items.rb
+- lib/dendroid/formatters/ascii_tree.rb
+- lib/dendroid/formatters/base_formatter.rb
+- lib/dendroid/formatters/bracket_notation.rb
 - lib/dendroid/grm_analysis/dotted_item.rb
 - lib/dendroid/grm_analysis/grm_analyzer.rb
-- lib/dendroid/grm_analysis/production_items.rb
+- lib/dendroid/grm_analysis/rule_items.rb
 - lib/dendroid/grm_dsl/base_grm_builder.rb
 - lib/dendroid/lexical/literal.rb
 - lib/dendroid/lexical/token.rb
 - lib/dendroid/lexical/token_position.rb
+- lib/dendroid/parsing/and_node.rb
+- lib/dendroid/parsing/chart_walker.rb
+- lib/dendroid/parsing/composite_parse_node.rb
+- lib/dendroid/parsing/empty_rule_node.rb
+- lib/dendroid/parsing/or_node.rb
+- lib/dendroid/parsing/parse_node.rb
+- lib/dendroid/parsing/parse_tree_visitor.rb
+- lib/dendroid/parsing/parser.rb
+- lib/dendroid/parsing/terminal_node.rb
+- lib/dendroid/parsing/walk_progress.rb
 - lib/dendroid/recognizer/chart.rb
 - lib/dendroid/recognizer/e_item.rb
 - lib/dendroid/recognizer/item_set.rb
 - lib/dendroid/recognizer/recognizer.rb
-- lib/dendroid/syntax/choice.rb
 - lib/dendroid/syntax/grammar.rb
 - lib/dendroid/syntax/grm_symbol.rb
 - lib/dendroid/syntax/non_terminal.rb
-- lib/dendroid/syntax/production.rb
 - lib/dendroid/syntax/rule.rb
 - lib/dendroid/syntax/symbol_seq.rb
 - lib/dendroid/syntax/terminal.rb
 - lib/dendroid/utils/base_tokenizer.rb
-- spec/dendroid/grm_analysis/alternative_item_spec.rb
-- spec/dendroid/grm_analysis/choice_items_spec.rb
 - spec/dendroid/grm_analysis/dotted_item_spec.rb
 - spec/dendroid/grm_analysis/grm_analyzer_spec.rb
-- spec/dendroid/grm_analysis/production_items_spec.rb
+- spec/dendroid/grm_analysis/rule_items_spec.rb
 - spec/dendroid/grm_dsl/base_grm_builder_spec.rb
 - spec/dendroid/lexical/literal_spec.rb
 - spec/dendroid/lexical/token_position_spec.rb
 - spec/dendroid/lexical/token_spec.rb
+- spec/dendroid/parsing/chart_walker_spec.rb
+- spec/dendroid/parsing/terminal_node_spec.rb
 - spec/dendroid/recognizer/chart_spec.rb
 - spec/dendroid/recognizer/e_item_spec.rb
 - spec/dendroid/recognizer/item_set_spec.rb
 - spec/dendroid/recognizer/recognizer_spec.rb
 - spec/dendroid/support/sample_grammars.rb
-- spec/dendroid/syntax/choice_spec.rb
 - spec/dendroid/syntax/grammar_spec.rb
 - spec/dendroid/syntax/grm_symbol_spec.rb
 - spec/dendroid/syntax/non_terminal_spec.rb
-- spec/dendroid/syntax/production_spec.rb
 - spec/dendroid/syntax/rule_spec.rb
 - spec/dendroid/syntax/symbol_seq_spec.rb
 - spec/dendroid/syntax/terminal_spec.rb
@@ -90,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.1
 signing_key:
 specification_version: 4
 summary: WIP. A Ruby implementation of an Earley parser

data/lib/dendroid/grm_analysis/alternative_item.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'dotted_item'
-
-module Dendroid
-  module GrmAnalysis
-    # A specialization of DottedItem specific for Choice (rule)
-    class AlternativeItem < DottedItem
-      # @return [Integer] the alternative number
-      attr_reader :alt_index
-
-      # Constructor.
-      # @param aChoice [Dendroid::Syntax::Choice]
-      # @param aPosition [Integer] Position of the dot in rhs of production.
-      # @param index [Integer] the rank of the alternative at hand
-      def initialize(aChoice, aPosition, index)
-        @alt_index = index
-        super(aChoice, aPosition)
-      end
-
-      # Return a String representation of the alternative item.
-      # @return [String]
-      def to_s
-        rhs_names = rule.alternatives[alt_index].members.map(&:to_s)
-        dotted_rhs = rhs_names.insert(position, '.')
-        "#{rule.head} => #{dotted_rhs.join(' ')}"
-      end
-
-      # Indicate whether the rhs of the alternative is empty
-      # @return [Boolean]
-      def empty?
-        rule.alternatives[alt_index].empty?
-      end
-
-      # Indicate whether the dot is at the start of rhs
-      # @return [Boolean]
-      def final_pos?
-        empty? || position == rule.alternatives[alt_index].size
-      end
-
-      alias completed? final_pos?
-
-      # Return the symbol right after the dot (if any)
-      # @return [Dendroid::Syntax::GrmSymbol, NilClass]
-      def next_symbol
-        return nil if empty? || completed?
-
-        rule.alternatives[alt_index].members[position]
-      end
-
-      # Test for equality with another dotted item.
-      # Two dotted items are equal if they refer to the same rule and
-      # have both the same rhs and dot positions.
-      # @return [Boolean]
-      def ==(other)
-        return true if eql?(other)
-
-        (position == other.position) && rule.eql?(other.rule) && (alt_index == other.alt_index)
-      end
-
-      private
-
-      def valid_position(aPosition)
-        raise StandardError if aPosition.negative? || aPosition > rule.alternatives[alt_index].size
-
-        aPosition
-      end
-    end # class
-  end # module
-end # module

data/lib/dendroid/grm_analysis/production_items.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'dotted_item'
-
-module Dendroid
-  module GrmAnalysis
-    # Mix-in module for extending the Dendroid::Syntax::Production class
-    # with dotted items manipulation methods and an attribute named `items`.
-    module ProductionItems
-      # Build the dotted items for this production and assign them
-      # to the `items` attributes
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def build_items
-        @items = if empty?
-                   [DottedItem.new(self, 0)]
-                 else
-                   (0..body.size).reduce([]) do |result, pos|
-                     result << GrmAnalysis::DottedItem.new(self, pos)
-                   end
-                 end
-      end
-
-      # Read accessor for the `items` attribute.
-      # Return the dotted items for this production
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def items
-        @items
-      end
-
-      # Return the predicted item (i.e. the dotted item with the dot at start)
-      # for this production.
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def predicted_items
-        [@items.first]
-      end
-
-      # Return the reduce item (i.e. the dotted item with the dot at end)
-      # for this production.
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def reduce_items
-        [@items.last]
-      end
-
-      # Return the next item given the provided item.
-      # In other words, advance the dot by one position.
-      # @param anItem [GrmAnalysis::DottedItem]
-      # @return [GrmAnalysis::DottedItem|NilClass]
-      def next_item(anItem)
-        return nil if anItem == @items.last
-
-        @items[anItem.position + 1]
-      end
-    end # module
-  end # module
-end # module

data/lib/dendroid/syntax/choice.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rule'
-
-module Dendroid
-  module Syntax
-    # A specialization of the Rule class.
-    # A choice is a rule with multiple rhs
-    class Choice < Rule
-      # @return [Array<Dendroid::Syntax::SymbolSeq>]
-      attr_reader :alternatives
-
-      # Create a Choice instance.
-      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
-      # @param alt [Array<Dendroid::Syntax::SymbolSeq>] the alternatives (each as a sequence of symbols).
-      def initialize(lhs, alt)
-        super(lhs)
-        @alternatives = valid_alternatives(alt)
-      end
-
-      # Predicate method to check whether the rule has alternatives
-      # @return [TrueClass]
-      def choice?
-        true
-      end
-
-      # Return the text representation of the choice
-      # @return [String]
-      def to_s
-        "#{head} => #{alternatives.join(' | ')}"
-      end
-
-      # Predicate method to check whether the choice rule body is productive.
-      # It is productive when at least of its alternative is productive.
-      # @return [Boolean]
-      def productive?
-        productive_alts = alternatives.select(&:productive?)
-        return false if productive_alts.empty?
-
-        @productive = Set.new(productive_alts)
-        head.productive = true
-      end
-
-      # Predicate method to check whether the rule has at least one empty alternative.
-      # @return [Boolean]
-      def empty?
-        alternatives.any?(&:empty?)
-      end
-
-      # Returns an array with the symbol sequence of its alternatives
-      # @return [Array<Dendroid::Syntax::SymbolSeq>]
-      def rhs
-        alternatives
-      end
-
-      # Equality operator
-      # Two production rules are equal when their head and alternatives are equal.
-      # @return [Boolean]
-      def ==(other)
-        return true if equal?(other)
-        return false if other.is_a?(Production)
-
-        (head == other.head) && (alternatives == other.alternatives)
-      end
-
-      private
-
-      def valid_alternatives(alt)
-        raise StandardError, "Expecting an Array, found a #{rhs.class} instead." unless alt.is_a?(Array)
-
-        if alt.size < 2
-          # A choice must have at least two alternatives
-          raise StandardError, "The choice for `#{head}` must have at least two alternatives."
-        end
-
-        # Verify that each array element is a valid symbol sequence
-        alt.each { |elem| valid_sequence(elem) }
-
-        # Fail when duplicate rhs found
-        alt_texts = alt.map(&:to_s)
-        no_duplicate = alt_texts.uniq
-        if alt_texts.size > no_duplicate.size
-          alt_texts.each_with_index do |str, i|
-            next if str == no_duplicate[i]
-
-            err_msg = "Duplicate alternatives: #{head} => #{alt_texts[i]}"
-            raise StandardError, err_msg
-          end
-        end
-
-        alt
-      end
-    end # class
-  end # module
-end # module