- These are actual benchmark results from Expressir parsing EXPRESS schemas. - The test file is 22KB with 733 lines of EXPRESS code. + These are actual benchmark results from Expressir parsing the SRL benchmark (135 schemas, 179K lines). + This represents a real-world production workload.
- Built with Rust's zero-cost abstractions for maximum performance. + Built with Rust's zero-cost abstractions for maximum performance. Native mode is 200-1300x faster than pure Ruby.
-| Pattern | +Ruby (i/s) | +Native (i/s) | +Speedup | +
|---|---|---|---|
| Simple string | +~575 | +~775,000 | +1,340x | +
| Repetition (unnamed) | +~560 | +~720,000 | +1,280x | +
| Alternative | +~575 | +~720,000 | +1,250x | +
| Sequence (3 parts) | +~580 | +~530,000 | +910x | +
| Named capture | +~575 | +~510,000 | +880x | +
| Calculator expression | +~570 | +~180,000 | +315x | +
| Repetition (named) | +~575 | +~125,000 | +220x | +
+
Slice objects with position information by default.
+
+
+ One method replaces five confusing options. The unified parse() API is simpler and more intuitive:
+
# Before 0.4.0 - Too many options! +parse_parslet(g, i) +parse_parslet_with_positions(g, i, cache) +parse_with_transform(g, i, cache) +parse_to_objects(g, i, map) +parse_raw(atom, i) + +# After 0.4.0 - One method to rule them all +result = Parsanol::Native.parse(grammar, input)+
All parse methods now return Parsanol::Slice objects
@@ -26,6 +45,16 @@
+ Parsanol 0.4.1 will support Ruby 4.0 via magnus 0.9.0
+ and rb-sys HEAD. These packages are not yet released.
+ The workspace Cargo.toml patches rb-sys automatically for ABI compatibility.
+
| Pattern Type | +Ruby (i/s) | +Native (i/s) | +Speedup | +
|---|---|---|---|
| Simple string | +~575 | +~775,000 | +1,340x | +
| Sequence (3 parts) | +~580 | +~530,000 | +910x | +
| Named capture | +~575 | +~510,000 | +880x | +
| Repetition (unnamed) | +~560 | +~720,000 | +1,280x | +
| Alternative | +~575 | +~720,000 | +1,250x | +
| Calculator expression | +~570 | +~180,000 | +315x | +
| Repetition (named) | +~575 | +~125,000 | +220x | +
+ Speedup varies by pattern complexity. Simple patterns show highest speedups (1000-1300x), + while patterns with named repetitions show lower speedups (200-400x) due to transformation overhead. +
+ + + +
+ Batch mode supports tagged AST nodes to preserve repetition and sequence semantics across the FFI boundary.
+ Tags like :repetition and :sequence
+ mark nodes for proper Ruby transformation.
+
+ Batch mode is ideal when you need correct Parslet-compatible semantics for complex grammars with + repetition patterns. It preserves the distinction between true repetitions and wrapper patterns. +
++# Batch mode with tagged AST nodes +result = Parsanol::Native.parse_batch(grammar, input) + +# Results preserve :repetition and :sequence tags +# This enables correct Ruby transformation for complex patterns+
| Pattern | +Example | +Result | +
|---|---|---|
| True Repetition | +[{x:1}, {x:2}] |
+ Array of hashes | +
| Wrapper Pattern | +{x: {y:1}, z:2} |
+ Single hash | +
| Duplicate Labels | +[{a:{x:1}}, {a:{y:2}}] |
+ Last value wins | +
+ line_and_column is computed lazily and cached.
+ This means zero overhead if you don't need position info,
+ but it's always available when you do.
+
class Parsanol::Slice
- # Core attributes
+ # Core attributes (always available, zero cost)
def content # String content
def offset # Byte offset in original input
def length # Length of the slice
+
+ # Lazy computation (computed on first access, then cached)
def line_and_column # [line, column] tuple (1-indexed)
# String compatibility
@@ -163,7 +326,7 @@ end
SLOW parsing
Pure Ruby
-SPEED: 1x (baseline) - 3036ms
+SPEED: 1x (baseline) - 425s (SRL benchmark)
- For maximum performance (~29x faster than pure Ruby), use the ZeroCopy interface + For maximum performance (~200-1300x faster than pure Ruby), use the ZeroCopy interface which bypasses Ruby transformation overhead. This is a separate low-level API from the 3 parse modes above.
@@ -672,7 +835,7 @@ end parser = JsonParser.new result = parser.parse('42', mode: :ruby) -# Speed: 1x (baseline) - 3036ms for 22KB EXPRESS schema +# Speed: 1x (baseline) - 425s for SRL benchmark (179K lines) # Returns Slice objects with position info` const modeNativeCode = `# Mode: Native (Recommended) @@ -690,7 +853,7 @@ parser = JsonParser.new # Just use mode: :native - position info is included! result = parser.parse('42', mode: :native) -# Speed: ~20x faster - 153ms for 22KB EXPRESS schema +# Speed: ~200-1300x faster depending on pattern # Returns Slice objects with position info # Access position info @@ -745,7 +908,7 @@ class MyParser < Parsanol::Parslet::Parser end parser = MyParser.new -result = parser.parse('42') # 20x faster with Rust backend! +result = parser.parse('42') # ~200-1300x faster with Rust backend! # Position info is included by default result.offset # => 0 diff --git a/src/views/docs/Comparison.vue b/src/views/docs/Comparison.vue index b24feb4..4c6a5ec 100644 --- a/src/views/docs/Comparison.vue +++ b/src/views/docs/Comparison.vue @@ -147,7 +147,7 @@Parsanol (after - no changes needed!)
require 'parsanol/parslet'
-class StringParser < Parslet::Parser # Same code, 35x faster!
+class StringParser < Parslet::Parser # Same code, ~17x faster!
rule(:string) { str('"') >> (str('\\') >> any | str('"').absent? >> any).repeat >> str('"') }
end
diff --git a/src/views/docs/RubyComparison.vue b/src/views/docs/RubyComparison.vue
index aa4d305..ec112cc 100644
--- a/src/views/docs/RubyComparison.vue
+++ b/src/views/docs/RubyComparison.vue
@@ -22,7 +22,7 @@
- The same parser runs 20-30x faster with Parsanol's Rust backend while maintaining full compatibility. + The same parser runs ~17x faster with Parsanol's Rust backend while maintaining full compatibility.
Rust parsing, Ruby AST construction
Direct FFI, with source positions