parsanol 1.3.13-arm-linux

data/lib/parsanol/native.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+require "parsanol/native/types"
+require "parsanol/native/parser"
+require "parsanol/native/serializer"
+require "parsanol/native/batch_decoder"
+
+module Parsanol
+  module Native
+    class << self
+      # Check if native extension is available
+      def available?
+        Parser.available?
+      end
+
+      # Parse input with a Ruby grammar, returning clean AST with lazy line/column.
+      #
+      # Uses batch FFI format for maximum performance (3-5x faster than object-by-object).
+      # The Rust-side transformation (to_parslet_compatible) produces Parslet-compatible
+      # output that can be consumed directly by Builder.build without additional
+      # Ruby-side transformation.
+      #
+      # @param grammar [Parsanol::Atoms::Base] Ruby grammar definition
+      # @param input [String] Input string to parse
+      # @return [Hash, Array, Parsanol::Slice] Transformed AST
+      #
+      # @example Simple parsing
+      #   result = Parsanol::Native.parse(str('hello').as(:greeting), 'hello')
+      #   # => {greeting: "hello"@0}
+      #
+      # @example With lazy line/column
+      #   result = Parsanol::Native.parse(str('hello').as(:greeting), "hello\nworld")
+      #   result[:greeting].line_and_column  # => [1, 1]
+      #
+      def parse(grammar, input)
+        raise LoadError, "Native parser not available" unless available?
+
+        # Handle both grammar atoms and pre-serialized JSON strings
+        grammar_json = if grammar.is_a?(String)
+                         grammar
+                       else
+                         Parser.serialize_grammar(grammar)
+                       end
+
+        # Use _parse_raw which returns properly tagged Ruby arrays via transform_ast.
+        # The batch format doesn't preserve :repetition/:sequence tags, so we use
+        # the direct FFI path. Apply the Ruby transformer to handle tags correctly.
+        begin
+          raw_ast = _parse_raw(grammar_json, input)
+        rescue RuntimeError => e
+          raise_native_parse_error(e, grammar, input)
+        end
+        BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice)
+      end
+
+      # Memory-bounded parsing without packrat cache.
+      #
+      # This creates a fresh arena and empty cache per call, bounding memory
+      # to AST size rather than input × atoms. Use for large files.
+      #
+      # @param grammar [Parsanol::Atoms::Base] Ruby grammar definition
+      # @param input [String] Input string to parse
+      # @return [Hash, Array, Parsanol::Slice] Transformed AST
+      def parse_fresh(grammar, input)
+        raise LoadError, "Native parser not available" unless available?
+
+        grammar_json = if grammar.is_a?(String)
+                         grammar
+                       else
+                         Parser.serialize_grammar(grammar)
+                       end
+
+        begin
+          raw_ast = _parse_fresh_raw(grammar_json, input)
+        rescue RuntimeError => e
+          raise_native_parse_error(e, grammar, input)
+        end
+        BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice)
+      end
+
+      # Parse and return RAW AST without transformation.
+      #
+      # This returns the raw Parslet intermediate format before any transformation.
+      # Use this only if you need the raw AST for custom processing.
+      #
+      # For most use cases (including Expressir), use parse() instead which
+      # returns properly transformed AST.
+      #
+      # @param grammar [Parsanol::Atoms::Base] Ruby grammar definition
+      # @param input [String] Input string to parse
+      # @return [Hash, Array] Raw untransformed AST
+      #
+      # @example Raw parsing
+      #   result = Parsanol::Native.parse_raw(str('hello').as(:greeting), 'hello')
+      #   # => {:syntax => [{:spaces => ...}, {:greeting => "hello"@0}, {:spaces => ...}]}
+      #
+      def parse_raw(grammar, input)
+        raise LoadError, "Native parser not available" unless available?
+
+        # Handle both grammar atoms and pre-serialized JSON strings
+        grammar_json = if grammar.is_a?(String)
+                         grammar
+                       else
+                         Parser.serialize_grammar(grammar)
+                       end
+
+        # Use batch_raw format for raw AST (no transformation)
+        slice_class = Parsanol::Slice
+        batch_data = _parse_batch_raw(grammar_json, input)
+
+        # Decode without transformation - raw AST format
+        BatchDecoder.decode(batch_data, input, slice_class)
+      end
+
+      # Fast batch parsing - uses u64 array format to minimize FFI overhead.
+      #
+      # This is 3-5x faster than regular parse() for large grammars.
+      # The batch format passes a flat u64 array across FFI, then decodes
+      # in pure Ruby, avoiding expensive per-node FFI calls.
+      #
+      # Returns RAW AST without transformation. For Expressir use case,
+      # use parse() instead which returns properly transformed AST.
+      #
+      # @param grammar_json [String] Pre-serialized grammar JSON
+      # @param input [String] Input string to parse
+      # @param slice_class [Class] The Slice class to use for string refs
+      # @return [Hash, Array, Slice] Raw AST (not transformed)
+      def parse_batch(grammar_json, input, slice_class)
+        raise LoadError, "Native parser not available" unless available?
+
+        # Call native extension's _parse_batch_raw method (named with _raw suffix
+        # to avoid conflict with this Ruby wrapper method)
+        batch_data = _parse_batch_raw(grammar_json, input)
+        BatchDecoder.decode(batch_data, input, slice_class)
+      end
+
+      # Serialize a Ruby grammar to JSON (cached).
+      #
+      # @param root_atom [Parsanol::Atoms::Base] Root atom of the grammar
+      # @return [String] JSON string
+      def serialize_grammar(root_atom)
+        Parser.serialize_grammar(root_atom)
+      end
+
+      # Clear grammar caches (call if grammar changes)
+      def clear_cache
+        Parser.clear_cache
+        clear_grammar_cache if available?
+      end
+
+      # Clear the Rust grammar cache to free memory.
+      #
+      # This is useful for batch processing scenarios where you want to
+      # limit memory usage by clearing unused grammars.
+      #
+      # @return [nil]
+      def clear_grammar_cache
+        raise LoadError, "Native parser not available" unless available?
+
+        _clear_grammar_cache
+      end
+
+      # Get the current number of cached grammars in Rust.
+      #
+      # @return [Integer] Number of cached grammars
+      def grammar_cache_size
+        raise LoadError, "Native parser not available" unless available?
+
+        _grammar_cache_size
+      end
+
+      # Get the grammar cache capacity.
+      #
+      # @return [Integer] Maximum cache capacity
+      def grammar_cache_capacity
+        raise LoadError, "Native parser not available" unless available?
+
+        _grammar_cache_capacity
+      end
+
+      # Get cache statistics
+      def cache_stats
+        stats = Parser.cache_stats
+        if available?
+          stats[:rust_grammar_cache_size] = grammar_cache_size
+          stats[:rust_grammar_cache_capacity] = grammar_cache_capacity
+        end
+        stats
+      end
+
+      # Translates a native backend failure into the Parsanol error protocol.
+      #
+      # When the grammar atom is at hand, reparses through the pure Ruby
+      # backend: a Ruby failure raises Parsanol::ParseFailed with the full
+      # cause-tree diagnostics, and a Ruby success recovers grammars the
+      # native serializer cannot express (e.g. custom atoms). For
+      # pre-serialized JSON grammars the native message is wrapped in a
+      # Parsanol::ParseFailed directly.
+      def raise_native_parse_error(error, grammar, input)
+        return grammar.parse(input) if grammar.respond_to?(:parse)
+
+        source = Parsanol::Source.new(input)
+        cause = Parsanol::Cause.new(error.message, source, source.bytepos)
+        raise Parsanol::ParseFailed.new(cause.to_s, cause)
+      end
+    end
+  end
+end
+
+# Attempt to load native extension
+begin
+  ruby_version = RUBY_VERSION.split(".").take(2).join(".")
+  require "parsanol/#{ruby_version}/parsanol_native"
+rescue LoadError
+  begin
+    require "parsanol/parsanol_native"
+  rescue LoadError
+    # Native extension not built yet
+  end
+end

data/lib/parsanol/optimizer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "ast_visitor"
+require_relative "optimizers/quantifier_optimizer"
+require_relative "optimizers/sequence_optimizer"
+require_relative "optimizers/choice_optimizer"
+require_relative "optimizers/lookahead_optimizer"
+require_relative "optimizers/cut_inserter"
+
+# Grammar-level optimizations for Parslet parsers
+# These optimizations transform the parser AST to reduce runtime overhead
+# without changing semantics.
+#
+# Architecture:
+# - Uses Visitor pattern for clean separation of traversal and transformation
+# - Each optimizer is a separate class inheriting from ASTVisitor
+# - Optimizer module provides facade methods for easy access
+module Parsanol
+  module Optimizer
+    # Simplifies redundant quantifiers in a parslet tree
+    # Example: str('a').repeat(1, 1) => str('a')
+    #          str('a').repeat(0, 1).repeat(0, 1) => str('a').repeat(0, 1)
+    #
+    # @param parslet [Parsanol::Atoms::Base] parslet to simplify
+    # @return [Parsanol::Atoms::Base] simplified parslet
+    def self.simplify_quantifiers(parslet)
+      Optimizers::QuantifierOptimizer.new.visit(parslet)
+    end
+
+    # Simplifies sequences by flattening and merging adjacent strings
+    # Example: str('a') >> str('b') => str('ab')
+    #          (str('a') >> str('b')) >> str('c') => str('abc')
+    #
+    # @param parslet [Parsanol::Atoms::Base] parslet to simplify
+    # @return [Parsanol::Atoms::Base] simplified parslet
+    def self.simplify_sequences(parslet)
+      Optimizers::SequenceOptimizer.new.visit(parslet)
+    end
+
+    # Simplifies choice/alternative patterns
+    # Example: (A | B) | C => A | B | C
+    #          A | B | A => A | B
+    #
+    # @param parslet [Parsanol::Atoms::Base] parslet to simplify
+    # @return [Parsanol::Atoms::Base] simplified parslet
+    def self.simplify_choices(parslet)
+      Optimizers::ChoiceOptimizer.new.visit(parslet)
+    end
+
+    # Simplifies lookahead patterns
+    # Example: !(!x) => &x (double negation elimination)
+    #
+    # @param parslet [Parsanol::Atoms::Base] parslet to simplify
+    # @return [Parsanol::Atoms::Base] simplified parslet
+    def self.simplify_lookaheads(parslet)
+      Optimizers::LookaheadOptimizer.new.visit(parslet)
+    end
+
+    # Automatically insert cut operators where safe (AC-FIRST algorithm)
+    # Inserts cuts after deterministic prefixes when alternatives have disjoint FIRST sets
+    # This enables O(1) space complexity by allowing aggressive cache eviction
+    #
+    # Example: str('if') >> x | str('while') >> y
+    #       => str('if').cut >> x | str('while').cut >> y
+    #
+    # @param parslet [Parsanol::Atoms::Base] parslet to optimize
+    # @return [Parsanol::Atoms::Base] optimized parslet with cuts inserted
+    def self.insert_cuts(parslet)
+      Optimizers::CutInserter.new.optimize(parslet)
+    end
+
+    # Apply all optimizations in recommended order
+    # This is a convenience method that applies all optimizer passes
+    #
+    # @param parslet [Parsanol::Atoms::Base] parslet to optimize
+    # @return [Parsanol::Atoms::Base] fully optimized parslet
+    def self.optimize_all(parslet)
+      result = simplify_quantifiers(parslet)
+      result = simplify_sequences(result)
+      result = simplify_choices(result)
+      result = simplify_lookaheads(result)
+      insert_cuts(result)
+    end
+  end
+end

data/lib/parsanol/optimizers/choice_optimizer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../ast_visitor"
+
+module Parsanol
+  module Optimizers
+    # Optimizes alternative/choice patterns in the AST
+    # Follows visitor pattern for clean separation of concerns
+    #
+    # Transformations:
+    # - (A | B) | C => A | B | C (flatten nested alternatives)
+    # - A | B | A => A | B (remove duplicates)
+    # - Alternative(A) => A (unwrap single-element alternatives)
+    class ChoiceOptimizer < ASTVisitor
+      # Visit an alternative node and apply choice optimizations
+      # @param parslet [Parsanol::Atoms::Alternative] alternative to optimize
+      # @return [Parsanol::Atoms::Base] optimized parslet
+      def visit_alternative(parslet)
+        # First optimize children recursively
+        new_alternatives = parslet.alternatives.map { |p| visit(p) }
+
+        # Optimization 1: Flatten nested alternatives
+        flattened = flatten_alternatives(new_alternatives)
+
+        # Optimization 2: Remove duplicate alternatives
+        deduplicated = deduplicate_alternatives(flattened)
+
+        # Optimization 3: Unwrap single-element alternatives
+        return deduplicated[0] if deduplicated.size == 1
+
+        # Return optimized alternative if changed
+        if deduplicated == parslet.alternatives
+          parslet
+        else
+          Parsanol::Atoms::Alternative.new(*deduplicated)
+        end
+      end
+
+      private
+
+      # Flatten nested alternatives into a single level
+      # @param alternatives [Array<Parsanol::Atoms::Base>] array of alternatives
+      # @return [Array<Parsanol::Atoms::Base>] flattened array
+      def flatten_alternatives(alternatives)
+        result = []
+        alternatives.each do |alt|
+          if alt.is_a?(Parsanol::Atoms::Alternative)
+            result.concat(alt.alternatives)
+          else
+            result << alt
+          end
+        end
+        result
+      end
+
+      # Remove duplicate alternatives using structural equality
+      # @param alternatives [Array<Parsanol::Atoms::Base>] array of alternatives
+      # @return [Array<Parsanol::Atoms::Base>] deduplicated array
+      def deduplicate_alternatives(alternatives)
+        return alternatives if alternatives.size < 2
+
+        # Use to_s as proxy for structural equality
+        seen = {}
+        result = []
+
+        alternatives.each do |alt|
+          key = alt.to_s
+          unless seen[key]
+            seen[key] = true
+            result << alt
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/parsanol/optimizers/cut_inserter.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+# Automatic Cut Insertion (AC-FIRST Algorithm)
+#
+# This optimizer implements the AC-FIRST algorithm from Mizushima et al. (2010)
+# to automatically insert cut operators when alternatives have disjoint FIRST sets.
+#
+# When all alternatives in a choice have non-overlapping FIRST sets, we can safely
+# insert a cut after the deterministic prefix, since backtracking will never be
+# needed.
+#
+# Example:
+#   str('if') >> condition >> then_clause |
+#   str('while') >> condition >> body |
+#   str('print') >> expression
+#
+# Becomes:
+#   str('if').cut >> condition >> then_clause |
+#   str('while').cut >> condition >> body |
+#   str('print').cut >> expression
+#
+# Reference: Mizushima et al. (2010) "Packrat Parsers Can Handle Practical
+# Grammars in Mostly Constant Space"
+#
+module Parsanol
+  module Optimizers
+    class CutInserter
+      # Optimize a parslet by inserting cuts where safe
+      # Recursively traverses the grammar AST
+      #
+      # @param parslet [Parsanol::Atoms::Base] The parslet to optimize
+      # @return [Parsanol::Atoms::Base] Optimized parslet with cuts inserted
+      def optimize(parslet)
+        case parslet
+        when Parsanol::Atoms::Alternative
+          optimize_alternative(parslet)
+        when Parsanol::Atoms::Sequence
+          optimize_sequence(parslet)
+        when Parsanol::Atoms::Repetition
+          optimize_repetition(parslet)
+        when Parsanol::Atoms::Named
+          optimize_named(parslet)
+        else
+          # Return atom unchanged (Str, Re, Lookahead, etc.)
+          parslet
+        end
+      end
+
+      private
+
+      # Optimize an Alternative atom by inserting cuts when all alternatives
+      # have disjoint FIRST sets
+      def optimize_alternative(alt)
+        alternatives = alt.alternatives
+        first_sets = alternatives.map(&:first_set)
+
+        # Only optimize if all FIRST sets are disjoint
+        unless Parsanol::FirstSet.all_disjoint?(first_sets)
+          # Not safe to insert cuts - return alternatives with recursive optimization
+          optimized = alternatives.map { |a| optimize(a) }
+          return Parsanol::Atoms::Alternative.new(*optimized)
+        end
+
+        # All FIRST sets are disjoint - safe to insert cuts!
+        # Insert cuts after deterministic prefixes
+        optimized = alternatives.map do |alternative|
+          insert_cut_if_safe(alternative)
+        end
+
+        Parsanol::Atoms::Alternative.new(*optimized)
+      end
+
+      # Optimize a Sequence atom by recursively optimizing its elements
+      def optimize_sequence(seq)
+        optimized_parslets = seq.parslets.map { |p| optimize(p) }
+        Parsanol::Atoms::Sequence.new(*optimized_parslets)
+      end
+
+      # Optimize a Repetition atom by recursively optimizing its parslet
+      def optimize_repetition(rep)
+        optimized_parslet = optimize(rep.parslet)
+        # Create new repetition with same min/max
+        # Note: We use default tag since it's not exposed as a reader
+        Parsanol::Atoms::Repetition.new(
+          optimized_parslet,
+          rep.min,
+          rep.max,
+        )
+      end
+
+      # Optimize a Named atom by recursively optimizing its parslet
+      def optimize_named(named)
+        optimized_parslet = optimize(named.parslet)
+        optimized_parslet.as(named.name)
+      end
+
+      # Insert a cut after the deterministic prefix if safe
+      # For sequences: find longest prefix without EPSILON
+      # For other atoms: cut the whole thing if it doesn't include EPSILON
+      def insert_cut_if_safe(parslet)
+        # For sequences, find the longest safe prefix
+        if parslet.is_a?(Parsanol::Atoms::Sequence)
+          prefix_parslets = find_deterministic_prefix(parslet)
+          if prefix_parslets && !prefix_parslets.empty?
+            return build_cut_sequence(parslet,
+                                      prefix_parslets)
+          end
+        end
+
+        # For other atoms, cut the whole thing if safe
+        return parslet.cut if safe_to_cut?(parslet)
+
+        # Not safe to cut - recursively optimize and return
+        optimize(parslet)
+      end
+
+      # Find the longest deterministic prefix of a sequence
+      # A deterministic prefix doesn't include EPSILON in its FIRST set
+      #
+      # @param sequence [Parsanol::Atoms::Sequence] The sequence to analyze
+      # @return [Array<Parsanol::Atoms::Base>] Prefix parslets, or nil if none
+      def find_deterministic_prefix(sequence)
+        parslets = sequence.parslets
+        prefix_length = 0
+
+        # Find longest prefix where no element can match empty
+        parslets.each do |p|
+          break if p.first_set.include?(Parsanol::FirstSet::EPSILON)
+
+          prefix_length += 1
+        end
+
+        prefix_length.positive? ? parslets[0...prefix_length] : nil
+      end
+
+      # Check if it's safe to cut after this parslet
+      # Safe if the parslet doesn't have EPSILON in its FIRST set
+      # (i.e., it always consumes input)
+      def safe_to_cut?(parslet)
+        first = parslet.first_set
+        # Don't cut if EPSILON is in FIRST set (might not consume)
+        # Also don't cut if FIRST set contains only nil (unknown)
+        return false if first.include?(Parsanol::FirstSet::EPSILON)
+        return false if first.all?(&:nil?)
+
+        true
+      end
+
+      # Build a new sequence with a cut after the prefix
+      #
+      # @param sequence [Parsanol::Atoms::Sequence] Original sequence
+      # @param prefix_parslets [Array] Parslets forming the deterministic prefix
+      # @return [Parsanol::Atoms::Base] New sequence with cut inserted
+      def build_cut_sequence(sequence, prefix_parslets)
+        # Recursively optimize prefix parslets
+        optimized_prefix = prefix_parslets.map { |p| optimize(p) }
+
+        # Build prefix (single parslet or sequence)
+        prefix = if optimized_prefix.length == 1
+                   optimized_prefix.first
+                 else
+                   Parsanol::Atoms::Sequence.new(*optimized_prefix)
+                 end
+
+        # Get remaining parslets after prefix
+        remaining = sequence.parslets[prefix_parslets.length..]
+
+        # Recursively optimize remaining parslets
+        optimized_remaining = remaining.map { |p| optimize(p) }
+
+        # Build final sequence with cut
+        if optimized_remaining.empty?
+          # Prefix is the entire sequence
+          prefix.cut
+        else
+          # Prefix + cut + remaining
+          Parsanol::Atoms::Sequence.new(prefix.cut, *optimized_remaining)
+        end
+      end
+    end
+  end
+end

data/lib/parsanol/optimizers/lookahead_optimizer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../ast_visitor"
+
+module Parsanol
+  module Optimizers
+    # Optimizes lookahead patterns in the AST
+    # Follows visitor pattern for clean separation of concerns
+    #
+    # Transformations:
+    # - !(!x) => &x (double negation elimination)
+    # - &(&x) => &x (positive lookahead is idempotent)
+    # - !(&x) => !x (negative of positive)
+    # - &(!x) => !x (positive of negative)
+    class LookaheadOptimizer < ASTVisitor
+      # Visit a lookahead node and apply lookahead optimizations
+      # @param parslet [Parsanol::Atoms::Lookahead] lookahead to optimize
+      # @return [Parsanol::Atoms::Base] optimized parslet
+      def visit_lookahead(parslet)
+        # First optimize the child
+        inner = visit(parslet.bound_parslet)
+
+        # If inner is also a lookahead, simplify nested lookaheads
+        if inner.is_a?(Parsanol::Atoms::Lookahead)
+          outer_positive = parslet.positive
+          inner_positive = inner.positive
+
+          # !(!x) => &x (double negation)
+          if !outer_positive && !inner_positive
+            return Parsanol::Atoms::Lookahead.new(inner.bound_parslet,
+                                                  true)
+          end
+
+          # &(&x) => &x (idempotent)
+          return inner if outer_positive && inner_positive
+
+          # !(&x) => !x (negative of positive)
+          if !outer_positive && inner_positive
+            return Parsanol::Atoms::Lookahead.new(inner.bound_parslet,
+                                                  false)
+          end
+
+          # &(!x) => !x (positive of negative)
+          return inner if outer_positive && !inner_positive
+        end
+
+        # Return lookahead with optimized child
+        if inner.equal?(parslet.bound_parslet)
+          parslet
+        else
+          Parsanol::Atoms::Lookahead.new(inner, parslet.positive)
+        end
+      end
+    end
+  end
+end

data/lib/parsanol/optimizers/quantifier_optimizer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../ast_visitor"
+
+module Parsanol
+  module Optimizers
+    # Optimizes repetition/quantifier patterns in the AST
+    # Follows visitor pattern for clean separation of concerns
+    #
+    # Transformations:
+    # - repeat(1,1) => unwrap (identity transformation)
+    # - repeat(0,1).repeat(0,1) => repeat(0,1) (idempotent)
+    # - repeat(n,n).repeat(m,m) => repeat(n*m,n*m) (multiply exact counts)
+    class QuantifierOptimizer < ASTVisitor
+      # Visit a repetition node and apply quantifier optimizations
+      # @param parslet [Parsanol::Atoms::Repetition] repetition to optimize
+      # @return [Parsanol::Atoms::Base] optimized parslet
+      def visit_repetition(parslet)
+        # First optimize the child
+        inner = visit(parslet.parslet)
+
+        # Optimization 1: repeat(1,1) is identity - unwrap it
+        return inner if parslet.min == 1 && parslet.max == 1
+
+        # Optimization 2: Nested repetitions
+        if inner.is_a?(Parsanol::Atoms::Repetition)
+          # repeat(0,1).repeat(0,1) => repeat(0,1) (idempotent)
+          if parslet.min.zero? && parslet.max == 1 &&
+              inner.min.zero? && inner.max == 1
+            return inner
+          end
+
+          # repeat(n,n).repeat(m,m) => repeat(n*m,n*m) for exact counts
+          if parslet.min == parslet.max && inner.min == inner.max &&
+              parslet.max && inner.max
+            new_count = parslet.min * inner.min
+            return Parsanol::Atoms::Repetition.new(
+              inner.parslet,
+              new_count,
+              new_count,
+              parslet.result_tag,
+            )
+          end
+        end
+
+        # Return optimized repetition with simplified child
+        if inner.equal?(parslet.parslet)
+          parslet
+        else
+          Parsanol::Atoms::Repetition.new(
+            inner,
+            parslet.min,
+            parslet.max,
+            parslet.result_tag,
+          )
+        end
+      end
+    end
+  end
+end