Repository: kevinmehall/rust-peg (language: rust)

Issue:
Support for threading a context object through to action code
Allow an object passed to the top-level parse call to be threaded through all parse functions and accessible to the action code.

~~~With a `#![context(T)]` at the top of the grammar source, all exposed parse functions  gain an extra argument of type `T`, which is exposed to actions as the `context` variable~~~.

Use cases: string interners, source mapping.



Discussion / hints:
Hi,
I really enjoy the rust-peg as I'm new to rust and I'm trying to build a small parser for a subset of matlab. Would be very delighted if this becomes an option, as I need to keep track of a variable table and a few more "meta" structures which to be accessible to every rule in the parser.
Also could you provide an example of using the context from a stand alone generated parser, since I do not want my cargo to depend on Nightly, I would much rather prefer to have it standalone build and than work with the parser source. 
Btw sorry, I'm new to rust and partially to github, do not know if this is the right place etc. Anyway, thanks for the package!

There might be a use case for a context object which is generic, especially if we need to use closures.

I needed global context objects for an indentation-scoped grammar, which is context-sensitive. Indentation is a "grammar local" implementation detail, and I'm not sure supplying an initial indentation level is the responsibility of end users of my parser. (Obviously I can wrap the parser, but the explicitness in the grammar is definitely a good principle.)

I've [hacked together](https://github.com/ebfull/rust-peg/tree/context-objects) static context rules which are initialized when ParserScope is created and available to all rules. I will make some improvements to efficiency/grammar and add tests, after some feedback of the overall design. (One potential problem is whether or not we should allow shadowing of context object bindings by tagged expressions.)

Here's my indentation example:

``` rust
use super::Statement;
use super::Line;
use std::char;

#[context]
indentation_level -> usize = {0}

#[pub]
parse -> Vec<Statement<'input>>
    = s:statements {s}

statements -> Vec<Statement<'input>>
    = s:statement+ {s}

statement -> Statement<'input>
    = l:line children:statement_children? {Statement{line: l, children: children}}

statement_children -> Vec<Statement<'input>>
    = INC_INDENT children:statements DEC_INDENT {children}
    / DEC_INDENT {? Err("children")}

line -> Line<'input>
    = SAME_INDENT line:line_expr __? EOL? {line}
    / SAME_INDENT EOL {Line{s: match_str}}

line_expr -> Line<'input>
    = ident:ident {Line{s: ident}}

ident -> &'input str
    = [a-z]+ {match_str}

EOL -> ()
    = "\r\n" / "\n" / "\r" {()}

INDENTATION -> usize
    = tabs:("    "/"\t")* { tabs.len() }

INC_INDENT -> ()
    = {*indentation_level = *indentation_level + 1; ()}

SAME_INDENT -> ()
    = i:INDENTATION {? if i == *indentation_level { Ok(()) } else {Err("same indentation")}}

DEC_INDENT -> ()
    = {*indentation_level = *indentation_level - 1; ()}

__ -> ()
    = (" "/"\t")+ {()}

```

~~I'd use this to pass a factory implementation to the grammar. This way the grammar would be generic and the factory could create different implementations from the same grammar rules.~~

I opened a new issue for my problem #113 

Use case: Filtering the parsing to what's relevnt. e.g. parsing httpd logs, one might want to throw away all the non ERROR logs so `if loglevel==ERROR { None } else { Some(match_str.to_string())`

Or: counting the number of fields in a csv file quickly.

The mentioned branch has been kicking about for over a year. Any chance that it will ever get merged?

Another option available now is to use [thread local storage](https://github.com/alexcrichton/scoped-tls).

If I were to add something like this, it would need to be redesigned. I'm moving away from all the unhygenic magic variable names like `context` and `match_str` in 0.4.

Separately from passed-in context, I plan to implement mutable state variables that are rolled back with backtracking for cases like whitespace-sensitive grammars. I think your "counting the number of fields in a csv file" case would fall under this category.


Fix patch:
diff --git a/README.md b/README.md
index 731a8ee..2ba5b59 100644
--- a/README.md
+++ b/README.md
@@ -114,6 +114,21 @@ ENUM = keyword<"enum">
 
 Templates are inlined every place they are used, and cannot be marked `pub`.
 
+### Context arguments
+
+You can pass parameters throughout the parser by adding a declaration like
+
+```
+#![arguments(filename: &str, interner: &mut Interner)]
+```
+
+to the top of your grammar. All public parse functions will take these additional arguments after
+the input string parameter, and they are available by name in all action code blocks.
+
+For an example see [the test](peg-syntax-ext/tests/grammar_args.rs).
+
+Be careful with mutable arguments. Remember that rule actions can run on parse paths that later fail and do not contribute to the final parse.
+
 ## Usage
 
 ### With a build script
diff --git a/src/grammar.rs b/src/grammar.rs
index 1679ce4..d3a89a4 100644
--- a/src/grammar.rs
+++ b/src/grammar.rs
@@ -59,11 +59,9 @@ if pos > self . max_err_pos {
 self . max_err_pos = pos ; self . expected . clear (  ) ; } if pos == self .
 max_err_pos { self . expected . insert ( expected ) ; } } Failed } } struct ParseState < 'input > { max_err_pos : usize , suppress_fail : usize , expected : :: std :: collections :: HashSet < & 'static str > , _phantom : :: std :: marker :: PhantomData < & 'input ( ) > , primary_cache : :: std :: collections :: HashMap < usize , RuleResult < Expr >> } impl < 'input > ParseState < 'input > { fn new ( ) -> ParseState < 'input > { ParseState { max_err_pos : 0 , suppress_fail : 0 , expected : :: std :: collections :: HashSet :: new ( ) , _phantom : :: std :: marker :: PhantomData , primary_cache : :: std :: collections :: HashMap :: new ( ) } } } 
 
- fn parse_grammar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Grammar > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_item ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , items ) => { Matched ( __pos , { 
-  Grammar::from_items(items)
- } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_items < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<Item> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_item ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , items ) => { Matched ( __pos , {  items  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_rule < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Rule > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = parse_exportflag ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , legacy_exported ) => { { let seq_res = parse_cacheflag ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , cached ) => { { let seq_res = parse_pubflag ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , public ) => { { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , name ) => { { let seq_res = parse_returntype ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , returns ) => { { let seq_res = parse_equals ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expression ) => { { let seq_res = match parse_semicolon ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_rule < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Rule > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse_exportflag ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , legacy_exported ) => { { let __seq_res = __parse_cacheflag ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , cached ) => { { let __seq_res = __parse_pubflag ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , public ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , name ) => { { let __seq_res = __parse_returntype ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , returns ) => { { let __seq_res = __parse_equals ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expression ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expression ) => { { let __seq_res = match __parse_semicolon ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
       Rule{
         name: name,
         expr: Box::new(expression),
@@ -73,31 +71,37 @@ max_err_pos { self . expected . insert ( expected ) ; } } Failed } } struct Pars
       }
      } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_pubflag < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < bool > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_PUB ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  true  } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , "" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  false  } ) } Failed => Failed , } } } } } 
+ fn __parse_pubflag < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < bool > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_PUB ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  true  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  false  } ) } Failed => Failed , } } } } } 
 
- fn parse_exportflag < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < bool > { # ! [ allow ( non_snake_case , unused ) ] { __state . suppress_fail += 1 ; let res = { let choice_res = { let seq_res = { let choice_res = slice_eq ( __input , __state , __pos , "#[export]" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "#[pub]" ) } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { true } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , "" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { false } ) } Failed => Failed , } } } } ; __state . suppress_fail -= 1 ; res } } 
+ fn __parse_exportflag < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < bool > { # ! [ allow ( non_snake_case , unused ) ] { __state . suppress_fail += 1 ; let res = { let __choice_res = { let __seq_res = { let __choice_res = slice_eq ( __input , __state , __pos , "#[export]" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "#[pub]" ) } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { true } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { false } ) } Failed => Failed , } } } } ; __state . suppress_fail -= 1 ; res } } 
 
- fn parse_cacheflag < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < bool > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "#[cache]" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { true } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => Matched ( __pos , { false } ) } } } 
+ fn __parse_cacheflag < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < bool > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "#[cache]" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { true } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => Matched ( __pos , { false } ) } } } 
 
- fn parse_template < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Template > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , name ) => { { let seq_res = parse_lt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_identifier ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , params ) => { { let seq_res = parse_gt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_equals ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expression ) => { { let seq_res = match parse_semicolon ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_template < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Template > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , name ) => { { let __seq_res = __parse_lt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . len ( ) > 0 { let __sep_res = __parse_comma ( __input , __state , __pos ) ; match __sep_res { Matched ( __newpos , _ ) => { __newpos } , Failed => break , } } else { __pos } ; let __step_res = __parse_identifier ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , params ) => { { let __seq_res = __parse_gt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_equals ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expression ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expression ) => { { let __seq_res = match __parse_semicolon ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
     Template { name: name, params: params, expr: Box::new(expression) }
    } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_item < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Item > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_rust_use ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , {  Item::Use(u)  } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_rule ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , r ) => { Matched ( __pos , {  Item::Rule(r)  } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_template ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , t ) => { Matched ( __pos , {  Item::Template(t)  } ) } Failed => Failed , } } } } } } } 
+ fn __parse_item < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Item > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_rust_use ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , u ) => { Matched ( __pos , {  Item::Use(u)  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_rule ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , r ) => { Matched ( __pos , {  Item::Rule(r)  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_template ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , t ) => { Matched ( __pos , {  Item::Template(t)  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_grammar_args ( __input , __state , __pos ) } } } } } } } 
 
- fn parse_returntype < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_returns ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match parse_rust_type ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , tp ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  tp.to_owned()  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => Matched ( __pos , {  "()".to_string()  } ) } } } 
+ fn __parse_grammar_args < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Item > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "#![" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "arguments" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_lparen ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . len ( ) > 0 { let __sep_res = __parse_comma ( __input , __state , __pos ) ; match __sep_res { Matched ( __newpos , _ ) => { __newpos } , Failed => break , } } else { __pos } ; let __step_res = __parse_grammar_argument ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse_rparen ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  Item::GrammarArgs(args)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_rust_identifier < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { __state . suppress_fail += 1 ; let res = { let seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_]" ) } ; match seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "identifier" ) ; Failed } } } } 
+ fn __parse_grammar_argument < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < (String, String) > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , i ) => { { let __seq_res = __parse_colon ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_type_string ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , t ) => { Matched ( __pos , {  (i, t)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_rust_use < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let seq_res = parse_USE ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_rust_path ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let seq_res = slice_eq ( __input , __state , __pos , "," ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = { let seq_res = parse_rust_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { match { let seq_res = slice_eq ( __input , __state , __pos , "as" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_rust_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } } Failed => Failed , } } } Failed => Failed , } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => match { let seq_res = slice_eq ( __input , __state , __pos , "as" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { parse_rust_identifier ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } } } } } ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , ";" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , v ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  v.to_owned()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_type_string < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match __parse_rust_type ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , tp ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  tp.to_owned()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_rust_path < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_rust_identifier ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } 
+ fn __parse_returntype < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_returns ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_type_string ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , tp ) => { Matched ( __pos , {  tp  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => Matched ( __pos , {  "()".to_string()  } ) } } } 
 
- fn parse_rust_type < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_rust_type ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "]" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match { let seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_rust_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { parse_rust_type ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_rust_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "," ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match seq_res { Matched ( __pos , _ ) => { parse_rust_identifier ( __input , __state , __pos ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rust_type ( __input , __state , __pos ) } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , ">" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_rust_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { parse_rust_type ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , "," ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_rust_type ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , ")" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rust_identifier ( __input , __state , __pos ) } } } } } } } } } } } 
+ fn __parse_rust_identifier < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "identifier" ) ; Failed } } } } 
 
- fn parse_expression < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] parse_choice ( __input , __state , __pos ) } 
+ fn __parse_rust_use < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let __seq_res = __parse_USE ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_rust_path ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . len ( ) > 0 { let __sep_res = { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } ; match __sep_res { Matched ( __newpos , _ ) => { __newpos } , Failed => break , } } else { __pos } ; let __step_res = { let __seq_res = __parse_rust_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { match { let __seq_res = slice_eq ( __input , __state , __pos , "as" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_rust_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => match { let __seq_res = slice_eq ( __input , __state , __pos , "as" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_rust_identifier ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } } } } } ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , ";" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , v ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  v.to_owned()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_choice < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = parse_sequence ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , head ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = { let seq_res = parse_slash ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_sequence ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , s ) => { Matched ( __pos , { s } ) } Failed => Failed , } } } Failed => Failed , } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , tail ) => { Matched ( __pos , { 
+ fn __parse_rust_path < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . len ( ) > 0 { let __sep_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; match __sep_res { Matched ( __newpos , _ ) => { __newpos } , Failed => break , } } else { __pos } ; let __step_res = __parse_rust_identifier ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } 
+
+ fn __parse_rust_type < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_rust_type ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "]" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = slice_eq ( __input , __state , __pos , "mut" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_rust_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { __parse_rust_type ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_rust_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . len ( ) > 0 { let __sep_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; match __sep_res { Matched ( __newpos , _ ) => { __newpos } , Failed => break , } } else { __pos } ; let __step_res = { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_rust_identifier ( __input , __state , __pos ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_rust_type ( __input , __state , __pos ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , ">" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_rust_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_rust_type ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . len ( ) > 0 { let __sep_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; match __sep_res { Matched ( __newpos , _ ) => { __newpos } , Failed => break , } } else { __pos } ; let __step_res = __parse_rust_type ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , ")" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_rust_identifier ( __input , __state , __pos ) } } } } } } } } } } } 
+
+ fn __parse_expression < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] __parse_choice ( __input , __state , __pos ) } 
+
+ fn __parse_choice < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse_sequence ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , head ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse_slash ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_sequence ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , { s } ) } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , tail ) => { Matched ( __pos , { 
       if tail.len() > 0 {
         let mut list = tail;
         list.insert(0, head);
@@ -107,9 +111,9 @@ max_err_pos { self . expected . insert ( expected ) ; } } Failed } } struct Pars
       }
      } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_sequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_labeled ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , elements ) => { { let seq_res = parse_action ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , code ) => { Matched ( __pos , { 
+ fn __parse_sequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_labeled ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , elements ) => { { let __seq_res = __parse_action ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , code ) => { Matched ( __pos , { 
       ActionExpr(elements, code.0, code.1)
-     } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_prefixed ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , elements ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_prefixed ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , elements ) => { Matched ( __pos , { 
       if elements.len() != 1 {
           SequenceExpr(elements)
       } else {
@@ -117,144 +121,144 @@ max_err_pos { self . expected . insert ( expected ) ; } } Failed } } struct Pars
       }
      } ) } Failed => Failed , } } } } } 
 
- fn parse_labeled < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < TaggedExpr > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , label ) => { { let seq_res = parse_colon ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_prefixed ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
+ fn __parse_labeled < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < TaggedExpr > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , label ) => { { let __seq_res = __parse_colon ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_prefixed ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
       TaggedExpr{ name: Some(label), expr: Box::new(expression) }
-     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_prefixed ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expr ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = __parse_prefixed ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { Matched ( __pos , { 
       TaggedExpr{ name: None, expr: Box::new(expr) }
    } ) } Failed => Failed , } } } } } 
 
- fn parse_prefixed < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_dollar ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_suffixed ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
+ fn __parse_prefixed < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_dollar ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_suffixed ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
       MatchStrExpr(Box::new(expression))
-     } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_and ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_suffixed ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_and ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_suffixed ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
       PosAssertExpr(Box::new(expression))
-     } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_not ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_suffixed ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_not ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_suffixed ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expression ) => { Matched ( __pos , { 
       NegAssertExpr(Box::new(expression))
-     } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_suffixed ( __input , __state , __pos ) } } } } } } } 
+     } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_suffixed ( __input , __state , __pos ) } } } } } } } 
 
- fn parse_suffixed < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_question ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_suffixed < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_question ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
        OptionalExpr(Box::new(e))
-     } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_starstar ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_repeatcount ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , count ) => { { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , sep ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_starstar ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_repeatcount ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , count ) => { { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , sep ) => { Matched ( __pos , { 
       Repeat(Box::new(e), count, Some(Box::new(sep)))
-     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_plusplus ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , sep ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_plusplus ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , sep ) => { Matched ( __pos , { 
       Repeat(Box::new(e), BoundedRepeat::Plus, Some(Box::new(sep)))
-     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_star ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_repeatcount ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , count ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_star ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_repeatcount ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , count ) => { Matched ( __pos , { 
       Repeat(Box::new(e), count, None)
-     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_plus ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_plus ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
       Repeat(Box::new(e), BoundedRepeat::Plus, None)
-     } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_primary ( __input , __state , __pos ) } } } } } } } } } } } 
+     } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_primary ( __input , __state , __pos ) } } } } } } } } } } } 
 
- fn parse_repeatcount < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < BoundedRepeat > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_lt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_repeatnum ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , n ) => { { let seq_res = parse_gt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  BoundedRepeat::Exact(n)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_lt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_repeatnum ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , min ) => { { let seq_res = parse_comma ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_repeatnum ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , max ) => { { let seq_res = parse_gt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  BoundedRepeat::Both(min, max)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , "" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  BoundedRepeat::None  } ) } Failed => Failed , } } } } } } } 
+ fn __parse_repeatcount < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < BoundedRepeat > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_lt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_repeatnum ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , n ) => { { let __seq_res = __parse_gt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  BoundedRepeat::Exact(n)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_lt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match __parse_repeatnum ( __input , __state , __pos ) { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , min ) => { { let __seq_res = __parse_comma ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match __parse_repeatnum ( __input , __state , __pos ) { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , max ) => { { let __seq_res = __parse_gt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  BoundedRepeat::Both(min, max)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  BoundedRepeat::None  } ) } Failed => Failed , } } } } } } } 
 
- fn parse_repeatnum < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_integer ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , i ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  i.to_string()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_lbrace ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_rust_expr ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_rbrace ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } 
+ fn __parse_repeatnum < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse_integer ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , i ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  i.to_string()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = __parse_lbrace ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_rust_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_rbrace ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } 
 
- fn parse_primary < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] if let Some ( entry ) = __state . primary_cache . get ( & __pos ) { return entry . clone ( ) ; } let rule_result = { let choice_res = { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , name ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = parse_lt ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = parse_returns ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = parse_equals ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_primary < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] if let Some ( entry ) = __state . primary_cache . get ( & __pos ) { return entry . clone ( ) ; } let __rule_result = { let __choice_res = { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , name ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = __parse_lt ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = __parse_returns ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = __parse_equals ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
       RuleExpr(name)
-     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , name ) => { { let seq_res = parse_lt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_expression ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , args ) => { { let seq_res = parse_gt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = parse_equals ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , name ) => { { let __seq_res = __parse_lt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . len ( ) > 0 { let __sep_res = __parse_comma ( __input , __state , __pos ) ; match __sep_res { Matched ( __newpos , _ ) => { __newpos } , Failed => break , } } else { __pos } ; let __step_res = __parse_expression ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse_gt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = __parse_equals ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
       TemplateInvoke(name, args)
-     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_literal ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_class ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = parse_dot ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  AnyCharExpr  } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "#position" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  PositionExpr  } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "#quiet" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_lt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_gt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  QuietExpr(Box::new(e))  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "#expected" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_lparen ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_doubleQuotedString ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , s ) => { { let seq_res = parse_rparen ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  FailExpr(s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "#infix" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_lt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , atom ) => { { let seq_res = parse_gt ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_lbrace ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_infix_level ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , repeat_value ) } else { Failed } } ; match seq_res { Matched ( __pos , levels ) => { { let seq_res = parse_rbrace ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixExpr{ atom: Box::new(atom), levels:levels } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_lparen ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , expression ) => { { let seq_res = parse_rparen ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  expression  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } } } } } } } } } } } } } } } } ; __state . primary_cache . insert ( __pos , rule_result . clone ( ) ) ; rule_result } 
+     } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_literal ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_class ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse_dot ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  AnyCharExpr  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "#position" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  PositionExpr  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "#quiet" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_lt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expression ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_gt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  QuietExpr(Box::new(e))  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "#expected" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_lparen ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_doubleQuotedString ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse_rparen ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  FailExpr(s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "#infix" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_lt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expression ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , atom ) => { { let __seq_res = __parse_gt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_lbrace ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_infix_level ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , __repeat_value ) } else { Failed } } ; match __seq_res { Matched ( __pos , levels ) => { { let __seq_res = __parse_rbrace ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixExpr{ atom: Box::new(atom), levels:levels } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = __parse_lparen ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expression ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expression ) => { { let __seq_res = __parse_rparen ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  expression  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } } } } } } } } } } } } } } } } ; __state . primary_cache . insert ( __pos , __rule_result . clone ( ) ) ; __rule_result } 
 
- fn parse_infix_level < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < InfixLevel > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "#L" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixAssoc::Left  } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , "#R" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixAssoc::Right } ) } Failed => Failed , } } } } ; match seq_res { Matched ( __pos , assoc ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_infix_op ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , repeat_value ) } else { Failed } } ; match seq_res { Matched ( __pos , operators ) => { Matched ( __pos , {  InfixLevel{ assoc: assoc, operators: operators}  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_infix_level < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < InfixLevel > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "#L" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixAssoc::Left  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "#R" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixAssoc::Right } ) } Failed => Failed , } } } } ; match __seq_res { Matched ( __pos , assoc ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_infix_op ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , __repeat_value ) } else { Failed } } ; match __seq_res { Matched ( __pos , operators ) => { Matched ( __pos , {  InfixLevel{ assoc: assoc, operators: operators}  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_infix_op < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < InfixOperator > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , l ) => { { let seq_res = match { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , var ) => { { let seq_res = parse_colon ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { var } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , op ) => { { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , e ) => { { let seq_res = parse_identifier ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , r ) => { { let seq_res = parse_lbrace ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_rust_expr ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , action ) => { { let seq_res = parse_rbrace ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixOperator{ operator:Box::new(e), action: action, l_arg:l, op_arg:op, r_arg:r }  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_infix_op < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < InfixOperator > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , l ) => { { let __seq_res = match { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , var ) => { { let __seq_res = __parse_colon ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { var } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , op ) => { { let __seq_res = __parse_primary ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , r ) => { { let __seq_res = __parse_lbrace ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_rust_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , action ) => { { let __seq_res = __parse_rbrace ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  InfixOperator{ operator:Box::new(e), action: action, l_arg:l, op_arg:op, r_arg:r }  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_rust_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = { let choice_res = parse_braced ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_nonBraceCharacters ( __input , __state , __pos ) } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , literal ) => { Matched ( __pos , {  format!("{{ {} }}", literal)  } ) } Failed => Failed , } } } 
+ fn __parse_rust_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = __parse_braced ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_nonBraceCharacters ( __input , __state , __pos ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , literal ) => { Matched ( __pos , {  format!("{{ {} }}", literal)  } ) } Failed => Failed , } } } 
 
- fn parse_action < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < (String, /*is conditional match?*/ bool) > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match slice_eq ( __input , __state , __pos , "?" ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , cond ) => { { let seq_res = parse_rust_expr ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , literal ) => { { let seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_action < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < (String, /*is conditional match?*/ bool) > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match slice_eq ( __input , __state , __pos , "?" ) { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , cond ) => { { let __seq_res = __parse_rust_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , literal ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
      (literal, cond.is_some())
    } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_braced < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = { let choice_res = parse_braced ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_nonBraceCharacters ( __input , __state , __pos ) } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "}" ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_braced < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = __parse_braced ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_nonBraceCharacters ( __input , __state , __pos ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "}" ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_nonBraceCharacters < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '{' | '}' => __state . mark_failure ( __pos , "[^{}]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^{}]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } 
+ fn __parse_nonBraceCharacters < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '{' | '}' => __state . mark_failure ( __pos , "[^{}]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^{}]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } 
 
- fn parse_equals < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_equals < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_colon < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_colon < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_semicolon < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_semicolon < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_slash < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_slash < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_and < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_and < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_not < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "!" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_not < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "!" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_dollar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "$" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_dollar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "$" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_question < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "?" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_question < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "?" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_star < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_star < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_starstar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "**" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_starstar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "**" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_plus < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_plus < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_plusplus < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "++" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_plusplus < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "++" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_lparen < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_lparen < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_rparen < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_rparen < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_dot < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "." ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_dot < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_returns < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "->" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_returns < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "->" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_lbrace < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_lbrace < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "{" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_rbrace < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_rbrace < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_comma < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "," ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_comma < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_lt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_lt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_gt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
+ fn __parse_gt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } 
 
- fn parse_USE < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "use" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_USE < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "use" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_PUB < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "pub" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_PUB < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "pub" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { __parse___ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_keyword < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_USE ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_PUB ( __input , __state , __pos ) } } } 
+ fn __parse_keyword < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_USE ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_PUB ( __input , __state , __pos ) } } } 
 
- fn parse_integer < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < usize > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , i ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  i.parse().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_integer < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < usize > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , i ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  i.parse().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_identifier < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { __state . suppress_fail += 1 ; let res = { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = parse_keyword ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match { let seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_]" ) } ; match seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , chars ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  chars.to_owned()  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "identifier" ) ; Failed } } } } 
+ fn __parse_identifier < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = __parse_keyword ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z0-9_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , chars ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  chars.to_owned()  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "identifier" ) ; Failed } } } } 
 
- fn parse_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let choice_res = parse_doubleQuotedString ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_singleQuotedString ( __input , __state , __pos ) } } ; match seq_res { Matched ( __pos , value ) => { { let seq_res = match slice_eq ( __input , __state , __pos , "i" ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , case_insensitive ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let __choice_res = __parse_doubleQuotedString ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_singleQuotedString ( __input , __state , __pos ) } } ; match __seq_res { Matched ( __pos , value ) => { { let __seq_res = match slice_eq ( __input , __state , __pos , "i" ) { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , case_insensitive ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
       LiteralExpr(value,case_insensitive.is_some())
      } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_string < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let choice_res = parse_doubleQuotedString ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_singleQuotedString ( __input , __state , __pos ) } } ; match seq_res { Matched ( __pos , string ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  string  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_string < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let __choice_res = __parse_doubleQuotedString ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_singleQuotedString ( __input , __state , __pos ) } } ; match __seq_res { Matched ( __pos , string ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  string  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_doubleQuotedString < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "\"" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_doubleQuotedCharacter ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , s ) => { { let seq_res = slice_eq ( __input , __state , __pos , "\"" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s.into_iter().collect()  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_doubleQuotedString < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "\"" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_doubleQuotedCharacter ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "\"" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s.into_iter().collect()  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_doubleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_simpleDoubleQuotedCharacter ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_simpleEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_zeroEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_hex2EscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_unicodeEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_eolEscapeSequence ( __input , __state , __pos ) } } } } } } } } } } } 
+ fn __parse_doubleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_simpleDoubleQuotedCharacter ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_simpleEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_zeroEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_hex2EscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_unicodeEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_eolEscapeSequence ( __input , __state , __pos ) } } } } } } } } } } } 
 
- fn parse_simpleDoubleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let choice_res = slice_eq ( __input , __state , __pos , "\"" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "\\" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_eolChar ( __input , __state , __pos ) } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.chars().next().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_simpleDoubleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let __choice_res = slice_eq ( __input , __state , __pos , "\"" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "\\" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_eolChar ( __input , __state , __pos ) } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.chars().next().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_singleQuotedString < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_singleQuotedCharacter ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , s ) => { { let seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s.into_iter().collect()  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_singleQuotedString < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_singleQuotedCharacter ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "'" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s.into_iter().collect()  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_singleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_simpleSingleQuotedCharacter ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_simpleEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_zeroEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_hex2EscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_unicodeEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_eolEscapeSequence ( __input , __state , __pos ) } } } } } } } } } } } 
+ fn __parse_singleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_simpleSingleQuotedCharacter ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_simpleEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_zeroEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_hex2EscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_unicodeEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_eolEscapeSequence ( __input , __state , __pos ) } } } } } } } } } } } 
 
- fn parse_simpleSingleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let choice_res = slice_eq ( __input , __state , __pos , "'" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "\\" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_eolChar ( __input , __state , __pos ) } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.chars().next().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_simpleSingleQuotedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let __choice_res = slice_eq ( __input , __state , __pos , "'" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "\\" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_eolChar ( __input , __state , __pos ) } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.chars().next().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_class < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match slice_eq ( __input , __state , __pos , "^" ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , inverted ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = { let choice_res = parse_classCharacterRange ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_classCharacter ( __input , __state , __pos ) } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , parts ) => { { let seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match slice_eq ( __input , __state , __pos , "i" ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , flags ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_class < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expr > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match slice_eq ( __input , __state , __pos , "^" ) { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , inverted ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = __parse_classCharacterRange ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_classCharacter ( __input , __state , __pos ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , parts ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match slice_eq ( __input , __state , __pos , "i" ) { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , flags ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
       CharSetExpr(inverted.is_some(), parts)
      } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_classCharacterRange < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < CharSetCase > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = parse_bracketDelimitedCharacter ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , begin ) => { { let seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_bracketDelimitedCharacter ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , end ) => { Matched ( __pos , { 
+ fn __parse_classCharacterRange < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < CharSetCase > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse_bracketDelimitedCharacter ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , begin ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_bracketDelimitedCharacter ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , end ) => { Matched ( __pos , { 
       //TODO: check start > end
       CharSetCase{start:begin, end:end}
      } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_classCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < CharSetCase > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = parse_bracketDelimitedCharacter ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , char_ ) => { Matched ( __pos , { 
+ fn __parse_classCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < CharSetCase > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = __parse_bracketDelimitedCharacter ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , char_ ) => { Matched ( __pos , { 
       CharSetCase{start:char_, end:char_}
      } ) } Failed => Failed , } } } 
 
- fn parse_bracketDelimitedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_simpleBracketDelimitedCharacter ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_simpleEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_zeroEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_hex2EscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_unicodeEscapeSequence ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_eolEscapeSequence ( __input , __state , __pos ) } } } } } } } } } } } 
+ fn __parse_bracketDelimitedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_simpleBracketDelimitedCharacter ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_simpleEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_zeroEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_hex2EscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_unicodeEscapeSequence ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_eolEscapeSequence ( __input , __state , __pos ) } } } } } } } } } } } 
 
- fn parse_simpleBracketDelimitedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let choice_res = slice_eq ( __input , __state , __pos , "]" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "\\" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_eolChar ( __input , __state , __pos ) } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.chars().next().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_simpleBracketDelimitedCharacter < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let __choice_res = slice_eq ( __input , __state , __pos , "]" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "\\" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_eolChar ( __input , __state , __pos ) } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.chars().next().unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_simpleEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "\\" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let choice_res = parse_digit ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "x" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "u" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_eolChar ( __input , __state , __pos ) } } } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { Matched ( __pos , { 
+ fn __parse_simpleEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "\\" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = { let __choice_res = __parse_digit ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "x" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "u" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_eolChar ( __input , __state , __pos ) } } } } } } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match any_char ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , { 
       match c.chars().next().unwrap() {
         //'b' => '\b',
         //'f' => '\f',
@@ -266,34 +270,34 @@ max_err_pos { self . expected . insert ( expected ) ; } } Failed } } struct Pars
       }
      } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_zeroEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "\\0" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = parse_digit ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  0u8 as char  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_zeroEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "\\0" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = __parse_digit ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  0u8 as char  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_hex2EscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "\\x" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match { let seq_res = parse_hexDigit ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { parse_hexDigit ( __input , __state , __pos ) } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , value ) => { Matched ( __pos , { 
+ fn __parse_hex2EscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "\\x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let __seq_res = __parse_hexDigit ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_hexDigit ( __input , __state , __pos ) } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , value ) => { Matched ( __pos , { 
       char::from_u32(u32::from_str_radix(value, 16).unwrap()).unwrap()
      } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_unicodeEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "\\u{" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_hexDigit ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , value ) => { { let seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
+ fn __parse_unicodeEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "\\u{" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_hexDigit ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , value ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "}" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
       char::from_u32(u32::from_str_radix(value, 16).unwrap()).unwrap()
      } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_eolEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "\\" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_eol ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  '\n'  } ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_eolEscapeSequence < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < char > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "\\" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eol ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  '\n'  } ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_digit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } } 
+ fn __parse_digit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } } 
 
- fn parse_hexDigit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } } 
+ fn __parse_hexDigit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } } 
 
- fn parse___ < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = { let choice_res = parse_whitespace ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_eol ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_comment ( __input , __state , __pos ) } } } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; __state . suppress_fail -= 1 ; res } } 
+ fn __parse___ < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = __parse_whitespace ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_eol ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_comment ( __input , __state , __pos ) } } } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; __state . suppress_fail -= 1 ; res } } 
 
- fn parse_comment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_singleLineComment ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_multiLineComment ( __input , __state , __pos ) } } } 
+ fn __parse_comment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_singleLineComment ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_multiLineComment ( __input , __state , __pos ) } } } 
 
- fn parse_singleLineComment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "//" ) ; match seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = parse_eolChar ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { any_char ( __input , __state , __pos ) } Failed => Failed , } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } } 
+ fn __parse_singleLineComment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "//" ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = __parse_eolChar ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { any_char ( __input , __state , __pos ) } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } } 
 
- fn parse_multiLineComment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = slice_eq ( __input , __state , __pos , "/*" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = { let seq_res = { __state . suppress_fail += 1 ; let __assert_res = slice_eq ( __input , __state , __pos , "*/" ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match seq_res { Matched ( __pos , _ ) => { any_char ( __input , __state , __pos ) } Failed => Failed , } } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "*/" ) } Failed => Failed , } } } Failed => Failed , } } } 
+ fn __parse_multiLineComment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "/*" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = { __state . suppress_fail += 1 ; let __assert_res = slice_eq ( __input , __state , __pos , "*/" ) ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } ; match __seq_res { Matched ( __pos , _ ) => { any_char ( __input , __state , __pos ) } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "*/" ) } Failed => Failed , } } } Failed => Failed , } } } 
 
- fn parse_eol < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = slice_eq ( __input , __state , __pos , "\n" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "\r\n" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "\r" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "\u{2028}" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "\u{2029}" ) } } } } } } } } } 
+ fn __parse_eol < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = slice_eq ( __input , __state , __pos , "\n" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "\r\n" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "\r" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = slice_eq ( __input , __state , __pos , "\u{2028}" ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "\u{2029}" ) } } } } } } } } } 
 
- fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } 
+ fn __parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } 
 
- fn parse_whitespace < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { ' ' | '\t' | '\u{a0}' | '\u{feff}' | '\u{1680}' | '\u{180e}' | '\u{2000}' ... '\u{200a}' | '\u{202f}' | '\u{205f}' | '\u{3000}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]" ) , } } else { __state . mark_failure ( __pos , "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]" ) } } 
+ fn __parse_whitespace < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { ' ' | '\t' | '\u{a0}' | '\u{feff}' | '\u{1680}' | '\u{180e}' | '\u{2000}' ... '\u{200a}' | '\u{202f}' | '\u{205f}' | '\u{3000}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]" ) , } } else { __state . mark_failure ( __pos , "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]" ) } } 
 
- pub fn grammar < 'input > ( input : & 'input str ) -> ParseResult < Grammar > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_grammar ( input , & mut state , 0 ) { Matched ( pos , value ) => { if pos == input . len ( ) { return Ok ( value ) } } _ => { } } let ( line , col ) = pos_to_line ( input , state . max_err_pos ) ; Err ( ParseError { line : line , column : col , offset : state . max_err_pos , expected : state . expected , } ) }
\ No newline at end of file
+ pub fn items < 'input > ( __input : & 'input str ) -> ParseResult < Vec<Item> > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_items ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) }
\ No newline at end of file
diff --git a/src/grammar.rustpeg b/src/grammar.rustpeg
index 3bfd6e0..c9957e1 100644
--- a/src/grammar.rustpeg
+++ b/src/grammar.rustpeg
@@ -1,9 +1,7 @@
 use translate::*;
 use std::char;
 
-pub grammar -> Grammar = __ items:item* {
-  Grammar::from_items(items)
-}
+pub items -> Vec<Item> = __ items:item* { items }
 
 rule -> Rule
   = legacy_exported:exportflag cached:cacheflag public:pubflag name:identifier returns: returntype equals expression:expression semicolon? {
@@ -26,12 +24,23 @@ template -> Template
   }
 
 item -> Item
-  = u:rust_use  { Item::Use(u) }
-  / r:rule      { Item::Rule(r) }
-  / t: template { Item::Template(t) }
+  = u:rust_use     { Item::Use(u) }
+  / r:rule         { Item::Rule(r) }
+  / t:template     { Item::Template(t) }
+  / grammar_args
+
+  grammar_args -> Item
+    = "#![" __ "arguments" __ lparen args:(grammar_argument**comma) rparen "]" __
+    { Item::GrammarArgs(args) }
+
+    grammar_argument -> (String, String)
+      = i:identifier colon t:type_string { (i, t) }
+
+
+type_string -> String = tp:$rust_type __ { tp.to_owned() }
 
 returntype -> String
-  = returns tp:$rust_type __ { tp.to_owned() }
+  = returns tp:type_string { tp }
   / { "()".to_string() }
 
 rust_identifier = #quiet<[a-zA-Z_][a-zA-Z0-9_]*> / #expected("identifier")
@@ -47,7 +56,7 @@ rust_path = rust_identifier ++ (__ "::" __)
 
 rust_type
   = "[" __ rust_type __ "]"
-  / "&" __ ("'" rust_identifier __)? rust_type
+  / "&" __ ("mut" __)? ("'" rust_identifier __)? rust_type
   / rust_identifier __ "<" __ (("'" rust_identifier) / rust_type) ** (__ "," __) __ ">"
   / rust_identifier __ "::" __ rust_type
   / "(" __ rust_type ** (__ "," __) __ ")"
diff --git a/src/lib.rs b/src/lib.rs
index dd87dbf..0c03bda 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,13 +16,14 @@ mod grammar;
 
 /// Compile a peg grammar to Rust source
 pub fn compile(input: &str) -> Result<String, String> {
-    let grammar_def = match grammar::grammar(&input) {
+    let ast_items = match grammar::items(&input) {
         Ok(g) => g,
         Err(msg) => {
             return Err(format!("Error parsing language specification: {}", msg))
         }
     };
 
+    let grammar_def = translate::Grammar::from_ast(ast_items)?;
     let output_tokens = translate::compile_grammar(&grammar_def);
     Ok(output_tokens?.to_string())
 }
diff --git a/src/translate.rs b/src/translate.rs
index ac758ee..59d6558 100644
--- a/src/translate.rs
+++ b/src/translate.rs
@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use quote::Tokens;
 pub use self::Expr::*;
 
+#[derive(Debug)]
 pub struct Error {
 	message: String,
 }
@@ -23,32 +24,73 @@ pub struct Grammar {
 	pub imports: Vec<String>,
 	pub rules: Vec<Rule>,
 	pub templates: HashMap<String, Template>,
+	pub args: Vec<(String, String)>,
 }
 
 impl Grammar {
-	pub fn from_items(items: Vec<Item>) -> Grammar {
+	pub fn from_ast(items: Vec<Item>) -> Result<Grammar, Error> {
 		let mut imports = Vec::new();
 		let mut rules = Vec::new();
 		let mut templates = HashMap::new();
+
+		let mut grammar_args = None;
+
 		for item in items {
 			match item {
 				Item::Use(u) => { imports.push(u); }
 				Item::Rule(rule) => { rules.push(rule); }
 				Item::Template(template) => { templates.insert(template.name.clone(), template); }
+				Item::GrammarArgs(args) => {
+					if grammar_args.is_none() {
+						grammar_args = Some(args);
+					} else {
+						Err(Error{ message: format!("Multiple #![grammar_args] attributes") })?
+					}
+				}
 			}
 		}
-		Grammar{ imports:imports, rules:rules, templates:templates }
+		Ok(Grammar{ imports:imports, rules:rules, templates:templates, args: grammar_args.unwrap_or(vec![]) })
 	}
 
 	fn find_rule(&self, name: &str) -> Option<&Rule> {
 		self.rules.iter().find(|rule| rule.name == name)
 	}
+
+	fn extra_args_def(&self) -> Tokens {
+		let args: Vec<Tokens> = self.args.iter().map(|&(ref name, ref tp)| {
+			let name = raw(name);
+			let tp = raw(tp);
+			quote!(, #name: #tp)
+		}).collect();
+		quote!(#(#args)*)
+	}
+
+	fn extra_args_call(&self) -> Tokens {
+		let args: Vec<Tokens> = self.args.iter().map(|&(ref name, _)| {
+			let name = raw(name);
+			quote!(, #name)
+		}).collect();
+		quote!(#(#args)*)
+	}
+
+	fn check_name(&self, name: &str) -> Result<(), Error> {
+		if name.starts_with("__") {
+			Err(Error{ message: format!("Capture variable `{}` begins with `__`, which is reserved for use by the parser generator", name) })?
+		}
+
+		if self.args.iter().any(|x| x.0 == name) {
+			Err(Error{ message: format!("Capture variable `{}` shadows grammar argument", name) })?
+		}
+
+		Ok(())
+	}
 }
 
 pub enum Item {
 	Use(String),
 	Rule(Rule),
 	Template(Template),
+	GrammarArgs(Vec<(String, String)>)
 }
 
 pub struct Rule {
@@ -252,7 +294,7 @@ pub fn compile_grammar(grammar: &Grammar) -> Result<Tokens, Error> {
 		items.push(compile_rule(grammar, rule)?)
 	}
 	items.extend(grammar.rules.iter().filter(|rule| rule.exported).map(|rule| {
-		compile_rule_export(rule)
+		compile_rule_export(grammar, rule)
 	}));
 
 	let view_items: Vec<_> = grammar.imports.iter().map(|x| raw(x)).collect();
@@ -306,7 +348,7 @@ fn make_parse_state(rules: &[Rule]) -> Tokens {
 
 fn compile_rule(grammar: &Grammar, rule: &Rule) -> Result<Tokens, Error> {
 	let ref rule_name = rule.name;
-	let name = raw(&format!("parse_{}", rule.name));
+	let name = raw(&format!("__parse_{}", rule.name));
 	let ret_ty = raw(&rule.ret_type);
 	let context = Context {
 		grammar: grammar,
@@ -333,6 +375,7 @@ fn compile_rule(grammar: &Grammar, rule: &Rule) -> Result<Tokens, Error> {
 	} else { body };
 
 	let nl = raw("\n\n"); // make output slightly more readable
+	let extra_args_def = grammar.extra_args_def();
 
 	Ok(if rule.cached {
 		let cache_field = raw(&format!("{}_cache", rule.name));
@@ -350,20 +393,20 @@ fn compile_rule(grammar: &Grammar, rule: &Rule) -> Result<Tokens, Error> {
 		};
 
 		quote! { #nl
-			fn #name<'input>(__input: &'input str, __state: &mut ParseState<'input>, __pos: usize) -> RuleResult<#ret_ty> {
+			fn #name<'input>(__input: &'input str, __state: &mut ParseState<'input>, __pos: usize #extra_args_def) -> RuleResult<#ret_ty> {
 				#![allow(non_snake_case, unused)]
 				if let Some(entry) = __state.#cache_field.get(&__pos) {
 					#cache_trace
 					return entry.clone();
 				}
-				let rule_result = #wrapped_body;
-				__state.#cache_field.insert(__pos, rule_result.clone());
-				rule_result
+				let __rule_result = #wrapped_body;
+				__state.#cache_field.insert(__pos, __rule_result.clone());
+				__rule_result
 			}
 		}
 	} else {
 		quote! { #nl
-			fn #name<'input>(__input: &'input str, __state: &mut ParseState<'input>, __pos: usize) -> RuleResult<#ret_ty> {
+			fn #name<'input>(__input: &'input str, __state: &mut ParseState<'input>, __pos: usize #extra_args_def) -> RuleResult<#ret_ty> {
 				#![allow(non_snake_case, unused)]
 				#wrapped_body
 			}
@@ -371,31 +414,34 @@ fn compile_rule(grammar: &Grammar, rule: &Rule) -> Result<Tokens, Error> {
 	})
 }
 
-fn compile_rule_export(rule: &Rule) -> Tokens {
+fn compile_rule_export(grammar: &Grammar, rule: &Rule) -> Tokens {
 	let name = raw(&rule.name);
 	let ret_ty = raw(&rule.ret_type);
-	let parse_fn = raw(&format!("parse_{}", rule.name));
+	let parse_fn = raw(&format!("__parse_{}", rule.name));
 	let nl = raw("\n\n"); // make output slightly more readable
+	let extra_args_def = grammar.extra_args_def();
+	let extra_args_call = grammar.extra_args_call();
+
 	quote! {
 		#nl
-		pub fn #name<'input>(input: &'input str) -> ParseResult<#ret_ty> {
+		pub fn #name<'input>(__input: &'input str #extra_args_def) -> ParseResult<#ret_ty> {
 			#![allow(non_snake_case, unused)]
-			let mut state = ParseState::new();
-			match #parse_fn(input, &mut state, 0) {
-				Matched(pos, value) => {
-					if pos == input.len() {
-						return Ok(value)
+			let mut __state = ParseState::new();
+			match #parse_fn(__input, &mut __state, 0 #extra_args_call) {
+				Matched(__pos, __value) => {
+					if __pos == __input.len() {
+						return Ok(__value)
 					}
 				}
 				_ => {}
 			}
-			let (line, col) = pos_to_line(input, state.max_err_pos);
+			let (__line, __col) = pos_to_line(__input, __state.max_err_pos);
 
 			Err(ParseError {
-				line: line,
-				column: col,
-				offset: state.max_err_pos,
-				expected: state.expected,
+				line: __line,
+				column: __col,
+				offset: __state.max_err_pos,
+				expected: __state.expected,
 			})
 		}
 	}
@@ -409,8 +455,8 @@ fn compile_match_and_then(cx: Context, e: &Expr, value_name: Option<&str>, then:
 	};
 
 	Ok(quote! {{
-		let seq_res = #seq_res;
-		match seq_res {
+		let __seq_res = #seq_res;
+		match __seq_res {
 			Matched(__pos, #name_pat) => { #then }
 			Failed => Failed,
 		}
@@ -517,12 +563,13 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 			if let Some(&(template_arg, lexical_context)) = cx.lexical.defs.get(&rule_name[..]) {
 				compile_expr(Context{ lexical: lexical_context, ..cx }, template_arg)?
 			} else if let Some(rule) = cx.grammar.find_rule(rule_name) {
-				let func = raw(&format!("parse_{}", rule_name));
+				let func = raw(&format!("__parse_{}", rule_name));
+				let extra_args_call = cx.grammar.extra_args_call();
 				if cx.result_used || rule.ret_type == "()" {
-					quote!{ #func(__input, __state, __pos) }
+					quote!{ #func(__input, __state, __pos #extra_args_call) }
 				} else {
 					quote!{
-						match #func(__input, __state, __pos) {
+						match #func(__input, __state, __pos #extra_args_call) {
 							Matched(pos, _) => Matched(pos, ()),
 							Failed => Failed,
 						}
@@ -571,8 +618,8 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 					let next = write_choice(cx, &exprs[1..])?;
 
 					Ok(quote! {{
-						let choice_res = #choice_res;
-						match choice_res {
+						let __choice_res = #choice_res;
+						match __choice_res {
 							Matched(__pos, __value) => Matched(__pos, __value),
 							Failed => #next
 						}
@@ -593,7 +640,7 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 			if cx.result_used {
 				quote!{
 					match #optional_res {
-						Matched(newpos, value) => { Matched(newpos, Some(value)) },
+						Matched(__newpos, __value) => { Matched(__newpos, Some(__value)) },
 						Failed => { Matched(__pos, None) },
 					}
 				}
@@ -620,10 +667,10 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 			let match_sep = if let &Some(ref sep) = sep {
 				let sep_inner = compile_expr(cx.result_used(false), &*sep)?;
 				quote! {
-					let __pos = if repeat_value.len() > 0 {
-						let sep_res = #sep_inner;
-						match sep_res {
-							Matched(newpos, _) => { newpos },
+					let __pos = if __repeat_value.len() > 0 {
+						let __sep_res = #sep_inner;
+						match __sep_res {
+							Matched(__newpos, _) => { __newpos },
 							Failed => break,
 						}
 					} else { __pos };
@@ -631,24 +678,24 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 			} else { quote!() };
 
 			let result = if cx.result_used {
-				quote!( repeat_value )
+				quote!( __repeat_value )
 			} else {
 				quote!( () )
 			};
 
 			let (repeat_vec, repeat_step) =
 			if cx.result_used || min.is_some() || max.is_some() || sep.is_some() {
-				(Some(quote! { let mut repeat_value = vec!(); }),
-				 Some(quote! { repeat_value.push(value); }))
+				(Some(quote! { let mut __repeat_value = vec!(); }),
+				 Some(quote! { __repeat_value.push(__value); }))
 			} else {
 				(None, None)
 			};
 
-			let max_check = max.map(|max| { quote! { if repeat_value.len() >= #max { break } }});
+			let max_check = max.map(|max| { quote! { if __repeat_value.len() >= #max { break } }});
 
 			let result_check = if let Some(min) = min {
 				quote!{
-					if repeat_value.len() >= #min {
+					if __repeat_value.len() >= #min {
 						Matched(__repeat_pos, #result)
 					} else {
 						Failed
@@ -668,10 +715,10 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 					#match_sep
 					#max_check
 
-					let step_res = #inner;
-					match step_res {
-						Matched(newpos, value) => {
-							__repeat_pos = newpos;
+					let __step_res = #inner;
+					match __step_res {
+						Matched(__newpos, __value) => {
+							__repeat_pos = __newpos;
 							#repeat_step
 						},
 						Failed => {
@@ -715,6 +762,11 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 				match exprs.first() {
 					Some(ref first) => {
 						let name = first.name.as_ref().map(|s| &s[..]);
+
+						if let Some(name) = name {
+							cx.grammar.check_name(name)?;
+						}
+
 						compile_match_and_then(cx, &*first.expr, name,
 							write_seq(cx, &exprs[1..], code, is_cond)?
 						)
@@ -746,7 +798,7 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 			quote! {{
 				let str_start = __pos;
 				match #inner {
-					Matched(newpos, _) => { Matched(newpos, &__input[str_start..newpos]) },
+					Matched(__newpos, _) => { Matched(__newpos, &__input[str_start..__newpos]) },
 					Failed => Failed,
 				}
 			}}
@@ -780,6 +832,8 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 			};
 
 			let mut level_code = Vec::new();
+			let extra_args_def = cx.grammar.extra_args_def();
+			let extra_args_call = cx.grammar.extra_args_call();
 
 			for (prec, level) in levels.iter().enumerate() {
 				let prec = prec as i32;
@@ -799,7 +853,7 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 
 					rules.push(quote!{
 						if let Matched(__pos, #op_arg) = #match_rule {
-							if let Matched(__pos, #r_arg) = __infix_parse(#new_prec, __input, __state, __pos) {
+							if let Matched(__pos, #r_arg) = __infix_parse(#new_prec, __input, __state, __pos #extra_args_call) {
 								let #l_arg = __infix_result;
 								__infix_result = #action;
 								__repeat_pos = __pos;
@@ -824,7 +878,7 @@ fn compile_expr(cx: Context, e: &Expr) -> Result<Tokens, Error> {
 			};
 
 			quote!{{
-				fn __infix_parse<'input>(__min_prec:i32, __input: &'input str, __state: &mut ParseState<'input>, __pos: usize) -> RuleResult<#ty> {
+				fn __infix_parse<'input>(__min_prec:i32, __input: &'input str, __state: &mut ParseState<'input>, __pos: usize #extra_args_def) -> RuleResult<#ty> {
 					if let Matched(__pos, mut __infix_result) = #match_atom {
 						#enter
 						let mut __repeat_pos = __pos;


Test patch:
diff --git a/peg-syntax-ext/tests/grammar_args.rs b/peg-syntax-ext/tests/grammar_args.rs
new file mode 100644
index 0000000..396221b
--- /dev/null
+++ b/peg-syntax-ext/tests/grammar_args.rs
@@ -0,0 +1,68 @@
+#![feature(plugin)]
+#![plugin(peg_syntax_ext)]
+
+use std::collections::HashMap;
+
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+pub struct Identifier(usize);
+
+pub struct Interner {
+    forward: HashMap<String, Identifier>,
+    backward: Vec<String>
+}
+
+impl Interner {
+    fn new() -> Interner {
+        Interner { forward: HashMap::new(), backward: Vec::new() }
+    }
+
+    fn intern(&mut self, s: &str) -> Identifier {
+        if let Some(&id) = self.forward.get(s) { id } else {
+            let id = Identifier(self.backward.len());
+            self.backward.push(s.to_owned());
+            self.forward.insert(s.to_owned(), id);
+            id
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Debug)]
+pub struct Spanned<T> {
+    file_id: usize,
+    start: usize,
+    end: usize,
+    node: T,
+}
+
+peg! parser(r#"
+use super::{Interner, Identifier, Spanned};
+
+#![arguments(file_id: usize, interner: &mut Interner)]
+
+pub outer_rule -> Vec<Spanned<Identifier>> = inner_rule**","
+
+inner_rule -> Spanned<Identifier> = spanned<identifier>
+
+spanned<X>
+    = start:#position node:X end:#position
+    { Spanned { file_id, start, end, node} }
+
+identifier -> Identifier
+    = s:$([a-z]+) { interner.intern(s) }
+
+"#);
+
+#[test]
+fn test_errors() {
+    let mut interner = Interner::new();
+    let result = parser::outer_rule("abcd,xyz,foobar,xyz", 23, &mut interner).unwrap();
+
+    assert_eq!(result, vec![
+        Spanned { file_id: 23, start: 0,  end: 4,  node: Identifier(0) },
+        Spanned { file_id: 23, start: 5,  end: 8,  node: Identifier(1) },
+        Spanned { file_id: 23, start: 9,  end: 15, node: Identifier(2) },
+        Spanned { file_id: 23, start: 16, end: 19, node: Identifier(1) },
+    ]);
+
+    println!("Ok");
+}