diff --git a/src/lib/desugar/eliminate_inline.mbt b/src/lib/desugar/eliminate_inline.mbt
index 87681b8..c6e1201 100644
--- a/src/lib/desugar/eliminate_inline.mbt
+++ b/src/lib/desugar/eliminate_inline.mbt
@@ -21,7 +21,7 @@ fn find_leaf_inline_rules(rules : Map[String, @elab.Rule]) -> Set[String] {
               Token(_) => true
               RuleCall(rule_name, [], _type) =>
                 not(all_inline_rules.contains(rule_name))
-              Param(_) | RuleCall(_, _, _) => panic()
+              Param(_) | RuleCall(_) | AnonmousInlineRule(_) => panic()
             }
           })
         })
@@ -44,7 +44,7 @@ fn eliminate_inline_rules(
       match item.term {
         Token(_) => false
         RuleCall(rule_name, [], _type) => inline_rules.contains(rule_name)
-        Param(_) | RuleCall(_, _, _) => panic()
+        Param(_) | RuleCall(_, _, _) | AnonmousInlineRule(_) => panic()
       }
     })
   }
@@ -60,7 +60,7 @@ fn eliminate_inline_rules(
             let rule = spec.rules[rule_name].unwrap()
             expand_points[index] = ({ val: 0 }, rule.clauses.length() - 1)
           }
-        Param(_) | RuleCall(_, _, _) => panic()
+        Param(_) | RuleCall(_, _, _) | AnonmousInlineRule(_) => panic()
       }
     }
     let expand_point_indexes = expand_points.keys().to_array()
@@ -127,7 +127,7 @@ fn eliminate_inline_rules(
             } else {
               new_items.push(item)
             }
-          Param(_) | RuleCall(_, _, _) => panic()
+          Param(_) | RuleCall(_, _, _) | AnonmousInlineRule(_) => panic()
         }
       }
       yield_({
diff --git a/src/lib/desugar/eliminate_parametric_rules.mbt b/src/lib/desugar/eliminate_parametric_rules.mbt
index f0a64d2..423b313 100644
--- a/src/lib/desugar/eliminate_parametric_rules.mbt
+++ b/src/lib/desugar/eliminate_parametric_rules.mbt
@@ -44,6 +44,7 @@ pub fn eliminate_rule_args(spec : @elab.ParserSpec) -> @elab.ParserSpec {
           Some(term) => term
           None => term
         }
+      AnonmousInlineRule(_) => panic()
     }
   }
 
@@ -139,6 +140,7 @@ fn derive_term_ident(term : @elab.Term) -> String {
     RuleCall(rule_name, [], _type) => rule_name
     RuleCall(rule_name, args, _type) =>
       rule_name + "__" + args.iter().map(derive_term_ident).join("_")
+    AnonmousInlineRule(_) => panic()
   }
 }
 
@@ -187,6 +189,7 @@ fn infer_return_type(
         Token(token) => token.type_
         Param(_, type_) => type_
         RuleCall(_, _, type_) => type_
+        AnonmousInlineRule(_) => panic()
       },
     )
   }
diff --git a/src/lib/driver/driver.mbt b/src/lib/driver/driver.mbt
index 9cf6344..b68816b 100644
--- a/src/lib/driver/driver.mbt
+++ b/src/lib/driver/driver.mbt
@@ -152,7 +152,7 @@ pub fn compile(
             Token(token) => T(get_terminal_by_name(token.name))
             RuleCall(rule_name, [], _type) =>
               NT(get_nonterminal_by_name(rule_name))
-            Param(_) | RuleCall(_, _, _) => panic()
+            Param(_) | RuleCall(_) | AnonmousInlineRule(_) => panic()
           }
         }),
         prec: clause.prec,
diff --git a/src/lib/elab/east.mbt b/src/lib/elab/east.mbt
index 54ee772..9d838d1 100644
--- a/src/lib/elab/east.mbt
+++ b/src/lib/elab/east.mbt
@@ -139,6 +139,7 @@ pub(all) enum Term {
   Token(Token)
   Param(String, TypeExpr)
   RuleCall(Symbol, Array[Term], TypeExpr)
+  AnonmousInlineRule(Array[Item], Action)
 }
 
 ///|
@@ -147,5 +148,6 @@ pub fn Item::type_(self : Item) -> TypeExpr {
     Token(token) => token.type_
     Param(_, type_) => type_
     RuleCall(_, _, type_) => type_
+    AnonmousInlineRule(_, action) => action.type_
   }
 }
diff --git a/src/lib/elab/elaborate.mbt b/src/lib/elab/elaborate.mbt
index f5739cc..e94ee50 100644
--- a/src/lib/elab/elaborate.mbt
+++ b/src/lib/elab/elaborate.mbt
@@ -175,6 +175,7 @@ pub fn elaborate(
           rule.type_,
         )
       }
+      AnonmousInlineRule(_, _) => ...
     }
   }
 
@@ -214,7 +215,7 @@ pub fn elaborate(
                 }
                 break
               }
-              Param(_) | RuleCall(_) => ()
+              Param(_) | RuleCall(_) | AnonmousInlineRule(_) => ()
             }
           }
           last_prec
diff --git a/src/lib/parser/ast.mbt b/src/lib/parser/ast.mbt
index cbac7a8..8649fa3 100644
--- a/src/lib/parser/ast.mbt
+++ b/src/lib/parser/ast.mbt
@@ -115,4 +115,5 @@ pub(all) enum Term {
   Symbol(Symbol)
   Image(String)
   RuleCall(Symbol, Array[Term])
+  AnonmousInlineRule(Array[ClauseItem], ClauseAction)
 } derive(ToJson)
diff --git a/src/lib/parser/parser.mbt b/src/lib/parser/parser.mbt
index edff25a..5743314 100644
--- a/src/lib/parser/parser.mbt
+++ b/src/lib/parser/parser.mbt
@@ -262,12 +262,14 @@ priv enum YYSymbol {
   NT_nonempty_type_expr_list
   NT_clause_list
   NT_clause
+  NT_clause_action_opt
   NT_clause_action
   NT_rule_prec
   NT_item_list
   NT_item
   NT_term
-  NT_nonempty_comma_term_list
+  NT_rule_arg
+  NT_nonempty_comma_rule_arg_list
   NT_nonempty_symbol_list
   NT_symbol
   EOI
@@ -300,44 +302,48 @@ fn yy_action_2(_last_pos : Position, _args : ArrayView[(YYObj, Position, Positio
 }
 
 fn yy_action_3(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj__String__String_(_dollar1)
-  YYObj_TypeExpr({();  Constr(pkg=Some(_dollar1.0), _dollar1.1, []) })
+  guard _args[0].0 is YYObj_Symbol(symbol)
+  guard _args[1].0 is YYObj__immut_list_T_Symbol_(symbol_list)
+  YYObj__immut_list_T_Symbol_({();  Cons(symbol, symbol_list) })
 }
 
 fn yy_action_4(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_Symbol(symbol)
-  guard _args[2].0 is YYObj__immut_list_T_Term_(_dollar3)
-  YYObj_Term({();  RuleCall(symbol, _dollar3.to_array()) })
+  guard _args[0].0 is YYObj__String__String_(_dollar1)
+  YYObj_TypeExpr({();  Constr(pkg=Some(_dollar1.0), _dollar1.1, []) })
 }
 
 fn yy_action_5(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_String(binder)
-  guard _args[2].0 is YYObj_Term(term)
-  YYObj_ClauseItem({();  { binder: Some(binder), term: term } })
+  guard _args[0].0 is YYObj_Symbol(symbol)
+  YYObj_Term({();  Symbol(symbol) })
 }
 
 fn yy_action_6(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_String(ident)
-  YYObj_Symbol({();  ident })
+  guard _args[0].0 is YYObj_Term(term)
+  YYObj_ClauseItem({();  { binder: None, term: term } })
 }
 
 fn yy_action_7(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[0].0 is YYObj_Term(term)
+  guard _args[2].0 is YYObj__immut_list_T_Term_(term_list)
+  YYObj__immut_list_T_Term_({();  Cons(term, term_list) })
+}
+
+fn yy_action_8(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Rule(rule)
   YYObj__immut_list_T_Rule_({();  Cons(rule, Nil) })
 }
 
-fn yy_action_8(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_9(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[3].0 is YYObj_TypeExpr(_dollar4)
   YYObj_TypeExpr({();  Arrow([], _dollar4) })
 }
 
-fn yy_action_9(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_Symbol(symbol)
-  guard _args[1].0 is YYObj__immut_list_T_Symbol_(symbol_list)
-  YYObj__immut_list_T_Symbol_({();  Cons(symbol, symbol_list) })
+fn yy_action_10(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[0].0 is YYObj_Term(term)
+  YYObj__immut_list_T_Term_({();  Cons(term, Nil) })
 }
 
-fn yy_action_10(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_11(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Symbol(nonterminal)
   guard _args[1].0 is YYObj_Array_String_(generic_params)
   guard _args[3].0 is YYObj__immut_list_T__String__TypeExpr___(param_list)
@@ -348,47 +354,54 @@ fn yy_action_10(_last_pos : Position, _args : ArrayView[(YYObj, Position, Positi
   })
 }
 
-fn yy_action_11(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_12(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_TypeExpr(_dollar2)
   guard _args[3].0 is YYObj__immut_list_T_TypeExpr_(_dollar4)
   guard _args[6].0 is YYObj_TypeExpr(_dollar7)
   YYObj_TypeExpr({();  Arrow(@immut/list.Cons(_dollar2, _dollar4).to_array(), _dollar7) })
 }
 
-fn yy_action_12(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_13(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj__immut_list_T_Symbol_(symbol_list)
   YYObj_Declaration({();  Token(symbol_list.to_array(), type_=None) })
 }
 
-fn yy_action_13(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_14(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   YYObj_TypeExpr({();  Constr(pkg=None, _dollar1, []) })
 }
 
-fn yy_action_14(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  YYObj__immut_list_T_ClauseItem_({();  Nil })
-}
-
 fn yy_action_15(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_Term(term)
-  YYObj__immut_list_T_Term_({();  Cons(term, Nil) })
+  guard _args[0].0 is YYObj_ClauseItem(item)
+  guard _args[1].0 is YYObj__immut_list_T_ClauseItem_(item_list)
+  YYObj__immut_list_T_ClauseItem_({();  Cons(item, item_list) })
 }
 
 fn yy_action_16(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[1].0 is YYObj_Symbol(symbol)
-  YYObj_Symbol_({();  Some(symbol) })
+  guard _args[0].0 is YYObj_String(image)
+  YYObj_Term({();  Image(image) })
 }
 
 fn yy_action_17(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  YYObj_Code_({();  None })
+  guard _args[0].0 is YYObj__String__Int__Array_SubstItem__(code)
+  let _start_pos = _args[0].1
+  let _end_pos = _args[0].2
+  YYObj_ClauseAction({(); 
+    let (code, utf8_pos, subst) = code
+    { code: Some({ code, utf8_pos, subst }), start: _start_pos, end: _end_pos }
+  })
 }
 
 fn yy_action_18(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  YYObj_Code_({();  None })
+}
+
+fn yy_action_19(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(code)
   YYObj_Code_({();  Some(code) })
 }
 
-fn yy_action_19(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_20(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Symbol(nonterminal)
   guard _args[1].0 is YYObj_TypeExpr_(type_)
   guard _args[3].0 is YYObj__immut_list_T_Clause_(clause_list)
@@ -397,135 +410,140 @@ fn yy_action_19(_last_pos : Position, _args : ArrayView[(YYObj, Position, Positi
   })
 }
 
-fn yy_action_20(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_21(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Rule(_dollar1)
   YYObj_Rule({();  _dollar1 })
 }
 
-fn yy_action_21(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_22(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_TypeExpr(_dollar2)
   YYObj_TypeExpr({();  _dollar2 })
 }
 
-fn yy_action_22(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_23(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj__immut_list_T_Symbol_(symbol_list)
   YYObj_Declaration({();  Left(symbol_list.to_array()) })
 }
 
-fn yy_action_23(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  YYObj_Code_({();  None })
-}
-
 fn yy_action_24(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_Symbol(symbol)
-  YYObj__immut_list_T_Symbol_({();  Cons(symbol, Nil) })
+  YYObj_Code_({();  None })
 }
 
 fn yy_action_25(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_ClauseItem(item)
-  guard _args[1].0 is YYObj__immut_list_T_ClauseItem_(item_list)
-  YYObj__immut_list_T_ClauseItem_({();  Cons(item, item_list) })
+  guard _args[0].0 is YYObj__immut_list_T_ClauseItem_(item_list)
+  guard _args[1].0 is YYObj_ClauseAction(action)
+  YYObj_Term({();  AnonmousInlineRule(item_list.to_array(), action) })
 }
 
 fn yy_action_26(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  YYObj_Symbol_({();  None })
+  guard _args[0].0 is YYObj_String(ident)
+  YYObj_Symbol({();  ident })
 }
 
 fn yy_action_27(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  YYObj_Symbol_({();  None })
+}
+
+fn yy_action_28(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[1].0 is YYObj_Symbol(symbol)
+  YYObj_Symbol_({();  Some(symbol) })
+}
+
+fn yy_action_29(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Clause(clause)
   YYObj__immut_list_T_Clause_({();  Cons(clause, Nil) })
 }
 
-fn yy_action_28(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_30(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_Rule(_dollar2)
   YYObj_Rule({();  { .._dollar2, inline: true } })
 }
 
-fn yy_action_29(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_31(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_TypeExpr(_dollar2)
   guard _args[3].0 is YYObj__immut_list_T_TypeExpr_(_dollar4)
   YYObj_TypeExpr({();  Tuple(@immut/list.Cons(_dollar2, _dollar4).to_array()) })
 }
 
-fn yy_action_30(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_32(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   guard _args[2].0 is YYObj_TypeExpr(_dollar3)
   guard _args[4].0 is YYObj__immut_list_T__String__TypeExpr___(_dollar5)
   YYObj__immut_list_T__String__TypeExpr___({();  Cons((_dollar1, Some(_dollar3)), _dollar5) })
 }
 
-fn yy_action_31(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_33(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   guard _args[2].0 is YYObj__immut_list_T_TypeExpr_(_dollar3)
   YYObj_TypeExpr({();  Constr(pkg=None, _dollar1, _dollar3.to_array()) })
 }
 
-fn yy_action_32(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_34(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Clause(clause)
   guard _args[2].0 is YYObj__immut_list_T_Clause_(clause_list)
   YYObj__immut_list_T_Clause_({();  Cons(clause, clause_list) })
 }
 
-fn yy_action_33(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_35(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   let _start_pos = _last_pos
   let _end_pos = _last_pos
   YYObj_ClauseAction({();  { code: None, start: _start_pos, end: _end_pos } })
 }
 
-fn yy_action_34(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_36(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   guard _args[2].0 is YYObj__immut_list_T_String_(_dollar3)
   YYObj__immut_list_T_String_({();  Cons(_dollar1, _dollar3) })
 }
 
-fn yy_action_35(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_37(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_TypeExpr(type_)
   YYObj_TypeExpr_({();  Some(type_) })
 }
 
-fn yy_action_36(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_38(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   YYObj__immut_list_T__String__TypeExpr___({();  Cons((_dollar1, None), Nil) })
 }
 
-fn yy_action_37(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_String(image)
-  YYObj_Term({();  Image(image) })
+fn yy_action_39(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[0].0 is YYObj_Symbol(symbol)
+  guard _args[2].0 is YYObj__immut_list_T_Term_(_dollar3)
+  YYObj_Term({();  RuleCall(symbol, _dollar3.to_array()) })
 }
 
-fn yy_action_38(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_40(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_TypeExpr(_dollar2)
   guard _args[5].0 is YYObj_TypeExpr(_dollar6)
   YYObj_TypeExpr({();  Arrow([_dollar2], _dollar6) })
 }
 
-fn yy_action_39(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_41(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(code)
   YYObj_Code_({();  Some(code) })
 }
 
-fn yy_action_40(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_42(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj__immut_list_T_Symbol_(symbol_list)
   YYObj_Declaration({();  Nonassoc(symbol_list.to_array()) })
 }
 
-fn yy_action_41(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_Term(term)
-  guard _args[2].0 is YYObj__immut_list_T_Term_(term_list)
-  YYObj__immut_list_T_Term_({();  Cons(term, term_list) })
+fn yy_action_43(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[0].0 is YYObj_Term(_dollar1)
+  YYObj_Term({();  _dollar1 })
 }
 
-fn yy_action_42(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_44(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj__immut_list_T_Symbol_(symbol_list)
   YYObj_Declaration({();  Right(symbol_list.to_array()) })
 }
 
-fn yy_action_43(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_45(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_TypeExpr(_dollar1)
   YYObj_TypeExpr({();  _dollar1 })
 }
 
-fn yy_action_44(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_46(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Code_(header)
   guard _args[1].0 is YYObj__immut_list_T_Declaration_(decl_list)
   guard _args[3].0 is YYObj__immut_list_T_Rule_(rule_list)
@@ -533,136 +551,136 @@ fn yy_action_44(_last_pos : Position, _args : ArrayView[(YYObj, Position, Positi
   YYObj_ParserSpec({();  { header, decls: decl_list.to_array(), rules: rule_list.to_array(), trailer } })
 }
 
-fn yy_action_45(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_Symbol(symbol)
-  YYObj_Term({();  Symbol(symbol) })
+fn yy_action_47(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[0].0 is YYObj_String(binder)
+  guard _args[2].0 is YYObj_Term(term)
+  YYObj_ClauseItem({();  { binder: Some(binder), term: term } })
 }
 
-fn yy_action_46(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_48(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[2].0 is YYObj_TypeExpr(type_)
   guard _args[4].0 is YYObj__immut_list_T_Symbol_(symbol_list)
   YYObj_Declaration({();  Type(symbol_list.to_array(), type_=type_) })
 }
 
-fn yy_action_47(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_49(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_TypeExpr(_dollar2)
   guard _args[4].0 is YYObj_TypeExpr(_dollar5)
   YYObj_TypeExpr({();  Arrow([_dollar2], _dollar5) })
 }
 
-fn yy_action_48(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_50(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj__String__String_(_dollar1)
   guard _args[2].0 is YYObj__immut_list_T_TypeExpr_(_dollar3)
   YYObj_TypeExpr({();  Constr(pkg=Some(_dollar1.0), _dollar1.1, _dollar3.to_array()) })
 }
 
-fn yy_action_49(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_51(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(code)
   YYObj_Code_({();  Some(code) })
 }
 
-fn yy_action_50(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_52(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[2].0 is YYObj_TypeExpr(type_)
   YYObj_Declaration({();  Position(type_=type_) })
 }
 
-fn yy_action_51(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_53(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   YYObj__immut_list_T_Declaration_({();  Nil })
 }
 
-fn yy_action_52(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj_Term(term)
-  YYObj_ClauseItem({();  { binder: None, term: term } })
+fn yy_action_54(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  YYObj__immut_list_T_ClauseItem_({();  Nil })
 }
 
-fn yy_action_53(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_55(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj__immut_list_T_Symbol_(symbol_list)
   YYObj_Declaration({();  Start(symbol_list.to_array()) })
 }
 
-fn yy_action_54(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_56(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   YYObj_Array_String_({();  [] })
 }
 
-fn yy_action_55(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_57(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_Rule(rule)
   guard _args[1].0 is YYObj__immut_list_T_Rule_(rule_list)
   YYObj__immut_list_T_Rule_({();  Cons(rule, rule_list) })
 }
 
-fn yy_action_56(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_58(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_TypeExpr(_dollar1)
   YYObj_TypeExpr({();  _dollar1 })
 }
 
-fn yy_action_57(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
-  guard _args[0].0 is YYObj__String__Int__Array_SubstItem__(code)
-  let _start_pos = _args[0].1
-  let _end_pos = _args[0].2
-  YYObj_ClauseAction({(); 
-      let (code, utf8_pos, subst) = code
-      { code: Some({ code, utf8_pos, subst }), start: _start_pos, end: _end_pos }
-  })
+fn yy_action_59(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[0].0 is YYObj_ClauseAction(_dollar1)
+  YYObj_ClauseAction({();  _dollar1 })
 }
 
-fn yy_action_58(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_60(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj__immut_list_T_ClauseItem_(item_list)
   guard _args[1].0 is YYObj_Symbol_(prec)
   guard _args[2].0 is YYObj_ClauseAction(action)
   YYObj_Clause({();  { items: item_list.to_array(), prec, action } })
 }
 
-fn yy_action_59(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_61(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_TypeExpr(type_expr)
   YYObj__immut_list_T_TypeExpr_({();  Cons(type_expr, Nil) })
 }
 
-fn yy_action_60(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_62(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[2].0 is YYObj_TypeExpr(type_)
   guard _args[4].0 is YYObj_Symbol(symbol)
   guard _args[5].0 is YYObj_String(image)
   YYObj_Declaration({();  Token1(symbol, type_=Some(type_), image=image) })
 }
 
-fn yy_action_61(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_63(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   YYObj__immut_list_T_String_({();  Cons(_dollar1, Nil) })
 }
 
-fn yy_action_62(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_64(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_TypeExpr(type_expr)
   guard _args[2].0 is YYObj__immut_list_T_TypeExpr_(type_expr_list)
   YYObj__immut_list_T_TypeExpr_({();  Cons(type_expr, type_expr_list) })
 }
 
-fn yy_action_63(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_65(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   guard _args[2].0 is YYObj__immut_list_T__String__TypeExpr___(_dollar3)
   YYObj__immut_list_T__String__TypeExpr___({();  Cons((_dollar1, None), _dollar3) })
 }
 
-fn yy_action_64(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_66(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   YYObj_TypeExpr_({();  None })
 }
 
-fn yy_action_65(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_67(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_String(_dollar1)
   guard _args[2].0 is YYObj_TypeExpr(_dollar3)
   YYObj__immut_list_T__String__TypeExpr___({();  Cons((_dollar1, Some(_dollar3)), Nil) })
 }
 
-fn yy_action_66(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_68(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj__immut_list_T_String_(_dollar2)
   YYObj_Array_String_({();  _dollar2.to_array() })
 }
 
-fn yy_action_67(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_69(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[1].0 is YYObj_Symbol(symbol)
   guard _args[2].0 is YYObj_String(image)
   YYObj_Declaration({();  Token1(symbol, type_=None, image=image) })
 }
 
-fn yy_action_68(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+fn yy_action_70(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
+  guard _args[0].0 is YYObj_Symbol(symbol)
+  YYObj__immut_list_T_Symbol_({();  Cons(symbol, Nil) })
+}
+
+fn yy_action_71(_last_pos : Position, _args : ArrayView[(YYObj, Position, Position)]) -> YYObj {
   guard _args[0].0 is YYObj_TypeExpr(_dollar1)
   YYObj_TypeExpr({();  Option(_dollar1) })
 }
@@ -706,25 +724,25 @@ fn yy_input(token : Token, _start_pos : Position, _end_pos : Position) -> (YYSym
 // [0, spec → • header decl_list PERCENT_PERCENT rule_list trailer EOF, $]
 // [1, header → • PERCENT_LBRACE_CODE_PERCENT_RBRACE, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 // [2, header → •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [69, spec_prime → • spec, $]
+// [72, spec_prime → • spec, $]
 fn yy_state_0(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     NT_spec => Shift(yy_state_1)
     T_PERCENT_LBRACE_CODE_PERCENT_RBRACE => Shift(yy_state_2)
     NT_header => Shift(yy_state_3)
-    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(0, NT_header, yy_action_23)
+    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(0, NT_header, yy_action_24)
     _ => Error
   }
 }
 
-// [69, spec_prime → spec •, $]
+// [72, spec_prime → spec •, $]
 fn yy_state_1(_lookahead : YYSymbol) -> YYDecision {
   Accept
 }
 
 // [1, header → PERCENT_LBRACE_CODE_PERCENT_RBRACE •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_2(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_header, yy_action_18)
+  ReduceNoLookahead(1, NT_header, yy_action_19)
 }
 
 // [0, spec → header • decl_list PERCENT_PERCENT rule_list trailer EOF, $]
@@ -753,7 +771,7 @@ fn yy_state_3(_lookahead : YYSymbol) -> YYDecision {
     T_PERCENT_START => Shift(yy_state_67)
     NT_decl => Shift(yy_state_69)
     NT_decl_list => Shift(yy_state_71)
-    T_PERCENT_PERCENT => Reduce(0, NT_decl_list, yy_action_51)
+    T_PERCENT_PERCENT => Reduce(0, NT_decl_list, yy_action_53)
     _ => Error
   }
 }
@@ -800,7 +818,7 @@ fn yy_state_5(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_6(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_COMMA => Shift(yy_state_7)
-    T_RANGLE | T_RBRACKET | T_RPAREN => Reduce(1, NT_nonempty_type_expr_list, yy_action_59)
+    T_RANGLE | T_RBRACKET | T_RPAREN => Reduce(1, NT_nonempty_type_expr_list, yy_action_61)
     _ => Error
   }
 }
@@ -836,7 +854,7 @@ fn yy_state_7(_lookahead : YYSymbol) -> YYDecision {
 
 // [49, nonempty_type_expr_list → type_expr COMMA nonempty_type_expr_list •, RANGLE / RBRACKET / RPAREN]
 fn yy_state_8(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_nonempty_type_expr_list, yy_action_62)
+  ReduceNoLookahead(3, NT_nonempty_type_expr_list, yy_action_64)
 }
 
 // [43, basic_type_expr → PKG_AND_IDENT •, RANGLE / RBRACKET / RPAREN / COMMA / QUESTION / COLON]
@@ -844,7 +862,7 @@ fn yy_state_8(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_9(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_LBRACKET => Shift(yy_state_10)
-    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(1, NT_basic_type_expr, yy_action_3)
+    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(1, NT_basic_type_expr, yy_action_4)
     _ => Error
   }
 }
@@ -888,7 +906,7 @@ fn yy_state_11(_lookahead : YYSymbol) -> YYDecision {
 
 // [45, basic_type_expr → PKG_AND_IDENT LBRACKET nonempty_type_expr_list RBRACKET •, RANGLE / RBRACKET / RPAREN / COMMA / QUESTION / COLON]
 fn yy_state_12(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(4, NT_basic_type_expr, yy_action_48)
+  ReduceNoLookahead(4, NT_basic_type_expr, yy_action_50)
 }
 
 // [42, basic_type_expr → IDENT •, RANGLE / RBRACKET / RPAREN / COMMA / QUESTION / COLON]
@@ -896,7 +914,7 @@ fn yy_state_12(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_13(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_LBRACKET => Shift(yy_state_14)
-    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(1, NT_basic_type_expr, yy_action_13)
+    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(1, NT_basic_type_expr, yy_action_14)
     _ => Error
   }
 }
@@ -940,12 +958,12 @@ fn yy_state_15(_lookahead : YYSymbol) -> YYDecision {
 
 // [44, basic_type_expr → IDENT LBRACKET nonempty_type_expr_list RBRACKET •, RANGLE / RBRACKET / RPAREN / COMMA / QUESTION / COLON]
 fn yy_state_16(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(4, NT_basic_type_expr, yy_action_31)
+  ReduceNoLookahead(4, NT_basic_type_expr, yy_action_33)
 }
 
 // [40, postfix_type_expr → basic_type_expr •, RANGLE / RBRACKET / RPAREN / COMMA / QUESTION / COLON]
 fn yy_state_17(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_postfix_type_expr, yy_action_43)
+  ReduceNoLookahead(1, NT_postfix_type_expr, yy_action_45)
 }
 
 // [35, type_expr → • postfix_type_expr, RPAREN / COMMA]
@@ -1039,7 +1057,7 @@ fn yy_state_21(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_22(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_ARROW => Shift(yy_state_23)
-    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(5, NT_basic_type_expr, yy_action_29)
+    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(5, NT_basic_type_expr, yy_action_31)
     _ => Error
   }
 }
@@ -1072,7 +1090,7 @@ fn yy_state_23(_lookahead : YYSymbol) -> YYDecision {
 
 // [39, type_expr → LPAREN type_expr COMMA nonempty_type_expr_list RPAREN ARROW type_expr •, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
 fn yy_state_24(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(7, NT_type_expr, yy_action_11)
+  ReduceNoLookahead(7, NT_type_expr, yy_action_12)
 }
 
 // [35, type_expr → postfix_type_expr •, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
@@ -1080,14 +1098,14 @@ fn yy_state_24(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_25(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_QUESTION => Shift(yy_state_26)
-    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_COLON => Reduce(1, NT_type_expr, yy_action_56)
+    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_COLON => Reduce(1, NT_type_expr, yy_action_58)
     _ => Error
   }
 }
 
 // [41, postfix_type_expr → postfix_type_expr QUESTION •, RANGLE / RBRACKET / RPAREN / COMMA / QUESTION / COLON]
 fn yy_state_26(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_postfix_type_expr, yy_action_68)
+  ReduceNoLookahead(2, NT_postfix_type_expr, yy_action_71)
 }
 
 // [38, type_expr → LPAREN type_expr COMMA RPAREN • ARROW type_expr, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
@@ -1126,7 +1144,7 @@ fn yy_state_28(_lookahead : YYSymbol) -> YYDecision {
 
 // [38, type_expr → LPAREN type_expr COMMA RPAREN ARROW type_expr •, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
 fn yy_state_29(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(6, NT_type_expr, yy_action_38)
+  ReduceNoLookahead(6, NT_type_expr, yy_action_40)
 }
 
 // [37, type_expr → LPAREN type_expr RPAREN • ARROW type_expr, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
@@ -1134,7 +1152,7 @@ fn yy_state_29(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_30(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_ARROW => Shift(yy_state_31)
-    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(3, NT_basic_type_expr, yy_action_21)
+    T_RANGLE | T_RBRACKET | T_RPAREN | T_COMMA | T_QUESTION | T_COLON => Reduce(3, NT_basic_type_expr, yy_action_22)
     _ => Error
   }
 }
@@ -1167,7 +1185,7 @@ fn yy_state_31(_lookahead : YYSymbol) -> YYDecision {
 
 // [37, type_expr → LPAREN type_expr RPAREN ARROW type_expr •, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
 fn yy_state_32(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(5, NT_type_expr, yy_action_47)
+  ReduceNoLookahead(5, NT_type_expr, yy_action_49)
 }
 
 // [36, type_expr → LPAREN RPAREN • ARROW type_expr, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
@@ -1206,7 +1224,7 @@ fn yy_state_34(_lookahead : YYSymbol) -> YYDecision {
 
 // [36, type_expr → LPAREN RPAREN ARROW type_expr •, RANGLE / RBRACKET / RPAREN / COMMA / COLON]
 fn yy_state_35(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(4, NT_type_expr, yy_action_8)
+  ReduceNoLookahead(4, NT_type_expr, yy_action_9)
 }
 
 // [18, decl → PERCENT_DERIVE LANGLE nonempty_type_expr_list • RANGLE IDENT, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
@@ -1231,9 +1249,9 @@ fn yy_state_38(_lookahead : YYSymbol) -> YYDecision {
 }
 
 // [17, decl → PERCENT_NONASSOC • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_39(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
@@ -1243,40 +1261,40 @@ fn yy_state_39(_lookahead : YYSymbol) -> YYDecision {
   }
 }
 
-// [68, symbol → IDENT •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_PREC / PERCENT_DERIVE / LBRACKET / LPAREN / RPAREN / COMMA / ARROW / COLON / BAR / SEMI]
+// [71, symbol → IDENT •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_PREC / PERCENT_DERIVE / LBRACKET / LPAREN / ARROW / COLON / BAR / SEMI]
 fn yy_state_40(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_symbol, yy_action_6)
+  ReduceNoLookahead(1, NT_symbol, yy_action_26)
 }
 
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → symbol •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → symbol • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → symbol •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → symbol • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_41(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
     NT_symbol => Shift(yy_state_41)
     NT_nonempty_symbol_list => Shift(yy_state_42)
-    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(1, NT_nonempty_symbol_list, yy_action_24)
+    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(1, NT_nonempty_symbol_list, yy_action_70)
     _ => Error
   }
 }
 
-// [67, nonempty_symbol_list → symbol nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → symbol nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_42(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_nonempty_symbol_list, yy_action_9)
+  ReduceNoLookahead(2, NT_nonempty_symbol_list, yy_action_3)
 }
 
 // [17, decl → PERCENT_NONASSOC nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_43(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_decl, yy_action_40)
+  ReduceNoLookahead(2, NT_decl, yy_action_42)
 }
 
 // [16, decl → PERCENT_RIGHT • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_44(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
@@ -1288,13 +1306,13 @@ fn yy_state_44(_lookahead : YYSymbol) -> YYDecision {
 
 // [16, decl → PERCENT_RIGHT nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_45(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_decl, yy_action_42)
+  ReduceNoLookahead(2, NT_decl, yy_action_44)
 }
 
 // [15, decl → PERCENT_LEFT • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_46(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
@@ -1306,7 +1324,7 @@ fn yy_state_46(_lookahead : YYSymbol) -> YYDecision {
 
 // [15, decl → PERCENT_LEFT nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_47(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_decl, yy_action_22)
+  ReduceNoLookahead(2, NT_decl, yy_action_23)
 }
 
 // [14, decl → PERCENT_POSITION • LANGLE type_expr RANGLE, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
@@ -1353,7 +1371,7 @@ fn yy_state_50(_lookahead : YYSymbol) -> YYDecision {
 
 // [14, decl → PERCENT_POSITION LANGLE type_expr RANGLE •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_51(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(4, NT_decl, yy_action_50)
+  ReduceNoLookahead(4, NT_decl, yy_action_52)
 }
 
 // [13, decl → PERCENT_TYPE • LANGLE type_expr RANGLE nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
@@ -1399,9 +1417,9 @@ fn yy_state_54(_lookahead : YYSymbol) -> YYDecision {
 }
 
 // [13, decl → PERCENT_TYPE LANGLE type_expr RANGLE • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_55(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
@@ -1413,16 +1431,16 @@ fn yy_state_55(_lookahead : YYSymbol) -> YYDecision {
 
 // [13, decl → PERCENT_TYPE LANGLE type_expr RANGLE nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_56(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(5, NT_decl, yy_action_46)
+  ReduceNoLookahead(5, NT_decl, yy_action_48)
 }
 
 // [9, decl → PERCENT_TOKEN • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 // [10, decl → PERCENT_TOKEN • LANGLE type_expr RANGLE nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 // [11, decl → PERCENT_TOKEN • symbol STRING, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 // [12, decl → PERCENT_TOKEN • LANGLE type_expr RANGLE symbol STRING, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / STRING / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / STRING / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_57(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
@@ -1434,25 +1452,25 @@ fn yy_state_57(_lookahead : YYSymbol) -> YYDecision {
 }
 
 // [11, decl → PERCENT_TOKEN symbol • STRING, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → symbol •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → symbol • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → symbol •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → symbol • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_58(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
     NT_symbol => Shift(yy_state_41)
     NT_nonempty_symbol_list => Shift(yy_state_42)
     T_STRING => Shift(yy_state_59)
-    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(1, NT_nonempty_symbol_list, yy_action_24)
+    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(1, NT_nonempty_symbol_list, yy_action_70)
     _ => Error
   }
 }
 
 // [11, decl → PERCENT_TOKEN symbol STRING •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_59(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_decl, yy_action_67)
+  ReduceNoLookahead(3, NT_decl, yy_action_69)
 }
 
 // [10, decl → PERCENT_TOKEN LANGLE • type_expr RANGLE nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
@@ -1493,9 +1511,9 @@ fn yy_state_61(_lookahead : YYSymbol) -> YYDecision {
 
 // [10, decl → PERCENT_TOKEN LANGLE type_expr RANGLE • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 // [12, decl → PERCENT_TOKEN LANGLE type_expr RANGLE • symbol STRING, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / STRING / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / STRING / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_62(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
@@ -1506,25 +1524,25 @@ fn yy_state_62(_lookahead : YYSymbol) -> YYDecision {
 }
 
 // [12, decl → PERCENT_TOKEN LANGLE type_expr RANGLE symbol • STRING, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → symbol •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → symbol • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → symbol •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → symbol • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_63(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
     NT_symbol => Shift(yy_state_41)
     NT_nonempty_symbol_list => Shift(yy_state_42)
     T_STRING => Shift(yy_state_64)
-    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(1, NT_nonempty_symbol_list, yy_action_24)
+    T_PERCENT_PERCENT | T_PERCENT_START | T_PERCENT_TOKEN | T_PERCENT_TYPE | T_PERCENT_POSITION | T_PERCENT_LEFT | T_PERCENT_RIGHT | T_PERCENT_NONASSOC | T_PERCENT_DERIVE => Reduce(1, NT_nonempty_symbol_list, yy_action_70)
     _ => Error
   }
 }
 
 // [12, decl → PERCENT_TOKEN LANGLE type_expr RANGLE symbol STRING •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_64(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(6, NT_decl, yy_action_60)
+  ReduceNoLookahead(6, NT_decl, yy_action_62)
 }
 
 // [10, decl → PERCENT_TOKEN LANGLE type_expr RANGLE nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
@@ -1534,13 +1552,13 @@ fn yy_state_65(_lookahead : YYSymbol) -> YYDecision {
 
 // [9, decl → PERCENT_TOKEN nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_66(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_decl, yy_action_12)
+  ReduceNoLookahead(2, NT_decl, yy_action_13)
 }
 
 // [8, decl → PERCENT_START • nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [66, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [67, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
-// [68, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [69, nonempty_symbol_list → • symbol, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [70, nonempty_symbol_list → • symbol nonempty_symbol_list, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
+// [71, symbol → • IDENT, IDENT / PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_67(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
@@ -1552,7 +1570,7 @@ fn yy_state_67(_lookahead : YYSymbol) -> YYDecision {
 
 // [8, decl → PERCENT_START nonempty_symbol_list •, PERCENT_PERCENT / PERCENT_START / PERCENT_TOKEN / PERCENT_TYPE / PERCENT_POSITION / PERCENT_LEFT / PERCENT_RIGHT / PERCENT_NONASSOC / PERCENT_DERIVE]
 fn yy_state_68(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_decl, yy_action_53)
+  ReduceNoLookahead(2, NT_decl, yy_action_55)
 }
 
 // [6, decl_list → • decl decl_list, PERCENT_PERCENT]
@@ -1581,7 +1599,7 @@ fn yy_state_69(_lookahead : YYSymbol) -> YYDecision {
     T_PERCENT_START => Shift(yy_state_67)
     NT_decl => Shift(yy_state_69)
     NT_decl_list => Shift(yy_state_70)
-    T_PERCENT_PERCENT => Reduce(0, NT_decl_list, yy_action_51)
+    T_PERCENT_PERCENT => Reduce(0, NT_decl_list, yy_action_53)
     _ => Error
   }
 }
@@ -1606,15 +1624,15 @@ fn yy_state_71(_lookahead : YYSymbol) -> YYDecision {
 // [22, rule → • PERCENT_INLINE rule_no_modifiers, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [23, rule_no_modifiers → • symbol opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [24, rule_no_modifiers → • symbol opt_rule_generic_params LPAREN nonempty_rule_param_list RPAREN opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-// [68, symbol → • IDENT, LBRACKET / LPAREN / ARROW / COLON]
+// [71, symbol → • IDENT, LBRACKET / LPAREN / ARROW / COLON]
 fn yy_state_72(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
     NT_symbol => Shift(yy_state_73)
-    T_PERCENT_INLINE => Shift(yy_state_124)
-    NT_rule_no_modifiers => Shift(yy_state_126)
-    NT_rule => Shift(yy_state_127)
-    NT_rule_list => Shift(yy_state_129)
+    T_PERCENT_INLINE => Shift(yy_state_128)
+    NT_rule_no_modifiers => Shift(yy_state_130)
+    NT_rule => Shift(yy_state_131)
+    NT_rule_list => Shift(yy_state_133)
     _ => Error
   }
 }
@@ -1630,9 +1648,9 @@ fn yy_state_73(_lookahead : YYSymbol) -> YYDecision {
     T_LBRACKET => Shift(yy_state_74)
     T_ARROW => Shift(yy_state_80)
     NT_opt_rule_generic_params => Shift(yy_state_82)
-    NT_opt_rule_return_type => Shift(yy_state_120)
-    T_COLON => Reduce(0, NT_opt_rule_return_type, yy_action_64)
-    T_LPAREN => Reduce(0, NT_opt_rule_generic_params, yy_action_54)
+    NT_opt_rule_return_type => Shift(yy_state_124)
+    T_COLON => Reduce(0, NT_opt_rule_return_type, yy_action_66)
+    T_LPAREN => Reduce(0, NT_opt_rule_generic_params, yy_action_56)
     _ => Error
   }
 }
@@ -1653,7 +1671,7 @@ fn yy_state_74(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_75(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_COMMA => Shift(yy_state_76)
-    T_RBRACKET => Reduce(1, NT_nonempty_comma_ident_list, yy_action_61)
+    T_RBRACKET => Reduce(1, NT_nonempty_comma_ident_list, yy_action_63)
     _ => Error
   }
 }
@@ -1671,7 +1689,7 @@ fn yy_state_76(_lookahead : YYSymbol) -> YYDecision {
 
 // [34, nonempty_comma_ident_list → IDENT COMMA nonempty_comma_ident_list •, RBRACKET]
 fn yy_state_77(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_nonempty_comma_ident_list, yy_action_34)
+  ReduceNoLookahead(3, NT_nonempty_comma_ident_list, yy_action_36)
 }
 
 // [32, opt_rule_generic_params → LBRACKET nonempty_comma_ident_list • RBRACKET, LPAREN]
@@ -1684,7 +1702,7 @@ fn yy_state_78(_lookahead : YYSymbol) -> YYDecision {
 
 // [32, opt_rule_generic_params → LBRACKET nonempty_comma_ident_list RBRACKET •, LPAREN]
 fn yy_state_79(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_opt_rule_generic_params, yy_action_66)
+  ReduceNoLookahead(3, NT_opt_rule_generic_params, yy_action_68)
 }
 
 // [25, opt_rule_return_type → ARROW • type_expr, COLON]
@@ -1715,7 +1733,7 @@ fn yy_state_80(_lookahead : YYSymbol) -> YYDecision {
 
 // [25, opt_rule_return_type → ARROW type_expr •, COLON]
 fn yy_state_81(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_opt_rule_return_type, yy_action_35)
+  ReduceNoLookahead(2, NT_opt_rule_return_type, yy_action_37)
 }
 
 // [24, rule_no_modifiers → symbol opt_rule_generic_params • LPAREN nonempty_rule_param_list RPAREN opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
@@ -1747,7 +1765,7 @@ fn yy_state_84(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_COMMA => Shift(yy_state_85)
     T_COLON => Shift(yy_state_87)
-    T_RPAREN => Reduce(1, NT_nonempty_rule_param_list, yy_action_36)
+    T_RPAREN => Reduce(1, NT_nonempty_rule_param_list, yy_action_38)
     _ => Error
   }
 }
@@ -1767,7 +1785,7 @@ fn yy_state_85(_lookahead : YYSymbol) -> YYDecision {
 
 // [29, nonempty_rule_param_list → IDENT COMMA nonempty_rule_param_list •, RPAREN]
 fn yy_state_86(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_nonempty_rule_param_list, yy_action_63)
+  ReduceNoLookahead(3, NT_nonempty_rule_param_list, yy_action_65)
 }
 
 // [28, nonempty_rule_param_list → IDENT COLON • type_expr, RPAREN]
@@ -1802,7 +1820,7 @@ fn yy_state_87(_lookahead : YYSymbol) -> YYDecision {
 fn yy_state_88(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_COMMA => Shift(yy_state_89)
-    T_RPAREN => Reduce(3, NT_nonempty_rule_param_list, yy_action_65)
+    T_RPAREN => Reduce(3, NT_nonempty_rule_param_list, yy_action_67)
     _ => Error
   }
 }
@@ -1822,7 +1840,7 @@ fn yy_state_89(_lookahead : YYSymbol) -> YYDecision {
 
 // [30, nonempty_rule_param_list → IDENT COLON type_expr COMMA nonempty_rule_param_list •, RPAREN]
 fn yy_state_90(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(5, NT_nonempty_rule_param_list, yy_action_30)
+  ReduceNoLookahead(5, NT_nonempty_rule_param_list, yy_action_32)
 }
 
 // [24, rule_no_modifiers → symbol opt_rule_generic_params LPAREN nonempty_rule_param_list • RPAREN opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
@@ -1840,7 +1858,7 @@ fn yy_state_92(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_ARROW => Shift(yy_state_80)
     NT_opt_rule_return_type => Shift(yy_state_93)
-    T_COLON => Reduce(0, NT_opt_rule_return_type, yy_action_64)
+    T_COLON => Reduce(0, NT_opt_rule_return_type, yy_action_66)
     _ => Error
   }
 }
@@ -1856,226 +1874,278 @@ fn yy_state_93(_lookahead : YYSymbol) -> YYDecision {
 // [24, rule_no_modifiers → symbol opt_rule_generic_params LPAREN nonempty_rule_param_list RPAREN opt_rule_return_type COLON • clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [50, clause_list → • clause, SEMI]
 // [51, clause_list → • clause BAR clause_list, SEMI]
-// [52, clause → • item_list rule_prec clause_action, BAR / SEMI]
-// [57, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [58, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [59, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [60, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [61, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [62, term → • symbol LPAREN nonempty_comma_term_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [63, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [68, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
+// [52, clause → • item_list rule_prec clause_action_opt, BAR / SEMI]
+// [58, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [59, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [60, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [61, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [62, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [63, term → • symbol LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [64, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [71, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
 fn yy_state_94(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_STRING => Shift(yy_state_95)
     NT_symbol => Shift(yy_state_96)
-    T_IDENT => Shift(yy_state_103)
-    NT_term => Shift(yy_state_106)
-    NT_item => Shift(yy_state_107)
-    NT_item_list => Shift(yy_state_109)
-    NT_clause => Shift(yy_state_115)
-    NT_clause_list => Shift(yy_state_118)
-    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_14)
+    T_IDENT => Shift(yy_state_104)
+    NT_item => Shift(yy_state_108)
+    NT_term => Shift(yy_state_109)
+    NT_item_list => Shift(yy_state_113)
+    NT_clause => Shift(yy_state_119)
+    NT_clause_list => Shift(yy_state_122)
+    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_54)
     _ => Error
   }
 }
 
-// [63, term → STRING •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+// [64, term → STRING •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
 fn yy_state_95(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_term, yy_action_37)
+  ReduceNoLookahead(1, NT_term, yy_action_16)
 }
 
-// [61, term → symbol •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
-// [62, term → symbol • LPAREN nonempty_comma_term_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+// [62, term → symbol •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+// [63, term → symbol • LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
 fn yy_state_96(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_LPAREN => Shift(yy_state_97)
-    T_IDENT | T_STRING | T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_RPAREN | T_COMMA | T_BAR | T_SEMI => Reduce(1, NT_term, yy_action_45)
+    T_IDENT | T_STRING | T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_RPAREN | T_COMMA | T_BAR | T_SEMI => Reduce(1, NT_term, yy_action_5)
     _ => Error
   }
 }
 
-// [61, term → • symbol, RPAREN / COMMA]
-// [62, term → • symbol LPAREN nonempty_comma_term_list RPAREN, RPAREN / COMMA]
-// [62, term → symbol LPAREN • nonempty_comma_term_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
-// [63, term → • STRING, RPAREN / COMMA]
-// [64, nonempty_comma_term_list → • term, RPAREN]
-// [65, nonempty_comma_term_list → • term COMMA nonempty_comma_term_list, RPAREN]
-// [68, symbol → • IDENT, LPAREN / RPAREN / COMMA]
+// [58, item_list → • item item_list, LBRACE_CODE_RBRACE]
+// [59, item_list → •, LBRACE_CODE_RBRACE]
+// [60, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE]
+// [61, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE]
+// [62, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / RPAREN / COMMA]
+// [63, term → • symbol LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / RPAREN / COMMA]
+// [63, term → symbol LPAREN • nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+// [64, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / RPAREN / COMMA]
+// [65, rule_arg → • term, RPAREN / COMMA]
+// [66, rule_arg → • item_list clause_action, RPAREN / COMMA]
+// [67, nonempty_comma_rule_arg_list → • rule_arg, RPAREN]
+// [68, nonempty_comma_rule_arg_list → • rule_arg COMMA nonempty_comma_rule_arg_list, RPAREN]
+// [71, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / LPAREN / RPAREN / COMMA]
 fn yy_state_97(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_IDENT => Shift(yy_state_40)
     T_STRING => Shift(yy_state_95)
     NT_symbol => Shift(yy_state_96)
-    NT_term => Shift(yy_state_98)
-    NT_nonempty_comma_term_list => Shift(yy_state_101)
+    NT_rule_arg => Shift(yy_state_98)
+    NT_item_list => Shift(yy_state_101)
+    T_IDENT => Shift(yy_state_104)
+    NT_term => Shift(yy_state_107)
+    NT_item => Shift(yy_state_108)
+    NT_nonempty_comma_rule_arg_list => Shift(yy_state_111)
+    T_LBRACE_CODE_RBRACE => Reduce(0, NT_item_list, yy_action_54)
     _ => Error
   }
 }
 
-// [64, nonempty_comma_term_list → term •, RPAREN]
-// [65, nonempty_comma_term_list → term • COMMA nonempty_comma_term_list, RPAREN]
+// [67, nonempty_comma_rule_arg_list → rule_arg •, RPAREN]
+// [68, nonempty_comma_rule_arg_list → rule_arg • COMMA nonempty_comma_rule_arg_list, RPAREN]
 fn yy_state_98(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_COMMA => Shift(yy_state_99)
-    T_RPAREN => Reduce(1, NT_nonempty_comma_term_list, yy_action_15)
+    T_RPAREN => Reduce(1, NT_nonempty_comma_rule_arg_list, yy_action_10)
     _ => Error
   }
 }
 
-// [61, term → • symbol, RPAREN / COMMA]
-// [62, term → • symbol LPAREN nonempty_comma_term_list RPAREN, RPAREN / COMMA]
-// [63, term → • STRING, RPAREN / COMMA]
-// [64, nonempty_comma_term_list → • term, RPAREN]
-// [65, nonempty_comma_term_list → • term COMMA nonempty_comma_term_list, RPAREN]
-// [65, nonempty_comma_term_list → term COMMA • nonempty_comma_term_list, RPAREN]
-// [68, symbol → • IDENT, LPAREN / RPAREN / COMMA]
+// [58, item_list → • item item_list, LBRACE_CODE_RBRACE]
+// [59, item_list → •, LBRACE_CODE_RBRACE]
+// [60, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE]
+// [61, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE]
+// [62, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / RPAREN / COMMA]
+// [63, term → • symbol LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / RPAREN / COMMA]
+// [64, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / RPAREN / COMMA]
+// [65, rule_arg → • term, RPAREN / COMMA]
+// [66, rule_arg → • item_list clause_action, RPAREN / COMMA]
+// [67, nonempty_comma_rule_arg_list → • rule_arg, RPAREN]
+// [68, nonempty_comma_rule_arg_list → • rule_arg COMMA nonempty_comma_rule_arg_list, RPAREN]
+// [68, nonempty_comma_rule_arg_list → rule_arg COMMA • nonempty_comma_rule_arg_list, RPAREN]
+// [71, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / LPAREN / RPAREN / COMMA]
 fn yy_state_99(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_IDENT => Shift(yy_state_40)
     T_STRING => Shift(yy_state_95)
     NT_symbol => Shift(yy_state_96)
-    NT_term => Shift(yy_state_98)
-    NT_nonempty_comma_term_list => Shift(yy_state_100)
+    NT_rule_arg => Shift(yy_state_98)
+    NT_nonempty_comma_rule_arg_list => Shift(yy_state_100)
+    NT_item_list => Shift(yy_state_101)
+    T_IDENT => Shift(yy_state_104)
+    NT_term => Shift(yy_state_107)
+    NT_item => Shift(yy_state_108)
+    T_LBRACE_CODE_RBRACE => Reduce(0, NT_item_list, yy_action_54)
     _ => Error
   }
 }
 
-// [65, nonempty_comma_term_list → term COMMA nonempty_comma_term_list •, RPAREN]
+// [68, nonempty_comma_rule_arg_list → rule_arg COMMA nonempty_comma_rule_arg_list •, RPAREN]
 fn yy_state_100(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_nonempty_comma_term_list, yy_action_41)
+  ReduceNoLookahead(3, NT_nonempty_comma_rule_arg_list, yy_action_7)
 }
 
-// [62, term → symbol LPAREN nonempty_comma_term_list • RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+// [55, clause_action → • LBRACE_CODE_RBRACE, RPAREN / COMMA]
+// [66, rule_arg → item_list • clause_action, RPAREN / COMMA]
 fn yy_state_101(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_RPAREN => Shift(yy_state_102)
+    NT_clause_action => Shift(yy_state_102)
+    T_LBRACE_CODE_RBRACE => Shift(yy_state_103)
     _ => Error
   }
 }
 
-// [62, term → symbol LPAREN nonempty_comma_term_list RPAREN •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+// [66, rule_arg → item_list clause_action •, RPAREN / COMMA]
 fn yy_state_102(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(4, NT_term, yy_action_4)
+  ReduceNoLookahead(2, NT_rule_arg, yy_action_25)
 }
 
-// [60, item → IDENT • EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [68, symbol → IDENT •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
+// [55, clause_action → LBRACE_CODE_RBRACE •, RPAREN / COMMA / BAR / SEMI]
 fn yy_state_103(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(1, NT_clause_action, yy_action_17)
+}
+
+// [61, item → IDENT • EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [71, symbol → IDENT •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / RPAREN / COMMA / BAR / SEMI]
+fn yy_state_104(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_EQ => Shift(yy_state_104)
-    T_IDENT | T_STRING | T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_LPAREN | T_BAR | T_SEMI => Reduce(1, NT_symbol, yy_action_6)
+    T_EQ => Shift(yy_state_105)
+    T_IDENT | T_STRING | T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_LPAREN | T_RPAREN | T_COMMA | T_BAR | T_SEMI => Reduce(1, NT_symbol, yy_action_26)
     _ => Error
   }
 }
 
-// [60, item → IDENT EQ • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [61, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [62, term → • symbol LPAREN nonempty_comma_term_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [63, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [68, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
-fn yy_state_104(_lookahead : YYSymbol) -> YYDecision {
+// [61, item → IDENT EQ • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [62, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [63, term → • symbol LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [64, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [71, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
+fn yy_state_105(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
     T_STRING => Shift(yy_state_95)
     NT_symbol => Shift(yy_state_96)
-    NT_term => Shift(yy_state_105)
+    NT_term => Shift(yy_state_106)
     _ => Error
   }
 }
 
-// [60, item → IDENT EQ term •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-fn yy_state_105(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_item, yy_action_5)
+// [61, item → IDENT EQ term •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+fn yy_state_106(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(3, NT_item, yy_action_47)
 }
 
-// [59, item → term •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-fn yy_state_106(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_item, yy_action_52)
-}
-
-// [57, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [57, item_list → item • item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [58, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [59, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [60, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [61, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [62, term → • symbol LPAREN nonempty_comma_term_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [63, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [68, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
+// [60, item → term •, IDENT / STRING / LBRACE_CODE_RBRACE]
+// [65, rule_arg → term •, RPAREN / COMMA]
 fn yy_state_107(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_STRING => Shift(yy_state_95)
-    NT_symbol => Shift(yy_state_96)
-    T_IDENT => Shift(yy_state_103)
-    NT_term => Shift(yy_state_106)
-    NT_item => Shift(yy_state_107)
-    NT_item_list => Shift(yy_state_108)
-    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_14)
+    T_IDENT | T_STRING | T_LBRACE_CODE_RBRACE => Reduce(1, NT_item, yy_action_6)
+    T_RPAREN | T_COMMA => Reduce(1, NT_rule_arg, yy_action_43)
     _ => Error
   }
 }
 
-// [57, item_list → item item_list •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [58, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [58, item_list → item • item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [59, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [60, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [61, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [62, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [63, term → • symbol LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [64, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [71, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
 fn yy_state_108(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_item_list, yy_action_25)
+  match _lookahead {
+    T_STRING => Shift(yy_state_95)
+    NT_symbol => Shift(yy_state_96)
+    T_IDENT => Shift(yy_state_104)
+    NT_item => Shift(yy_state_108)
+    NT_term => Shift(yy_state_109)
+    NT_item_list => Shift(yy_state_110)
+    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_54)
+    _ => Error
+  }
 }
 
-// [52, clause → item_list • rule_prec clause_action, BAR / SEMI]
-// [55, rule_prec → • PERCENT_PREC symbol, LBRACE_CODE_RBRACE / BAR / SEMI]
-// [56, rule_prec → •, LBRACE_CODE_RBRACE / BAR / SEMI]
+// [60, item → term •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
 fn yy_state_109(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(1, NT_item, yy_action_6)
+}
+
+// [58, item_list → item item_list •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+fn yy_state_110(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(2, NT_item_list, yy_action_15)
+}
+
+// [63, term → symbol LPAREN nonempty_comma_rule_arg_list • RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+fn yy_state_111(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_PERCENT_PREC => Shift(yy_state_110)
-    NT_rule_prec => Shift(yy_state_112)
-    T_LBRACE_CODE_RBRACE | T_BAR | T_SEMI => Reduce(0, NT_rule_prec, yy_action_26)
+    T_RPAREN => Shift(yy_state_112)
     _ => Error
   }
 }
 
-// [55, rule_prec → PERCENT_PREC • symbol, LBRACE_CODE_RBRACE / BAR / SEMI]
-// [68, symbol → • IDENT, LBRACE_CODE_RBRACE / BAR / SEMI]
-fn yy_state_110(_lookahead : YYSymbol) -> YYDecision {
+// [63, term → symbol LPAREN nonempty_comma_rule_arg_list RPAREN •, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / RPAREN / COMMA / BAR / SEMI]
+fn yy_state_112(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(4, NT_term, yy_action_39)
+}
+
+// [52, clause → item_list • rule_prec clause_action_opt, BAR / SEMI]
+// [56, rule_prec → • PERCENT_PREC symbol, LBRACE_CODE_RBRACE / BAR / SEMI]
+// [57, rule_prec → •, LBRACE_CODE_RBRACE / BAR / SEMI]
+fn yy_state_113(_lookahead : YYSymbol) -> YYDecision {
+  match _lookahead {
+    T_PERCENT_PREC => Shift(yy_state_114)
+    NT_rule_prec => Shift(yy_state_116)
+    T_LBRACE_CODE_RBRACE | T_BAR | T_SEMI => Reduce(0, NT_rule_prec, yy_action_27)
+    _ => Error
+  }
+}
+
+// [56, rule_prec → PERCENT_PREC • symbol, LBRACE_CODE_RBRACE / BAR / SEMI]
+// [71, symbol → • IDENT, LBRACE_CODE_RBRACE / BAR / SEMI]
+fn yy_state_114(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
-    NT_symbol => Shift(yy_state_111)
+    NT_symbol => Shift(yy_state_115)
     _ => Error
   }
 }
 
-// [55, rule_prec → PERCENT_PREC symbol •, LBRACE_CODE_RBRACE / BAR / SEMI]
-fn yy_state_111(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_rule_prec, yy_action_16)
+// [56, rule_prec → PERCENT_PREC symbol •, LBRACE_CODE_RBRACE / BAR / SEMI]
+fn yy_state_115(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(2, NT_rule_prec, yy_action_28)
 }
 
-// [52, clause → item_list rule_prec • clause_action, BAR / SEMI]
-// [53, clause_action → • LBRACE_CODE_RBRACE, BAR / SEMI]
-// [54, clause_action → •, BAR / SEMI]
-fn yy_state_112(_lookahead : YYSymbol) -> YYDecision {
+// [52, clause → item_list rule_prec • clause_action_opt, BAR / SEMI]
+// [53, clause_action_opt → • clause_action, BAR / SEMI]
+// [54, clause_action_opt → •, BAR / SEMI]
+// [55, clause_action → • LBRACE_CODE_RBRACE, BAR / SEMI]
+fn yy_state_116(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_LBRACE_CODE_RBRACE => Shift(yy_state_113)
-    NT_clause_action => Shift(yy_state_114)
-    T_BAR | T_SEMI => Reduce(0, NT_clause_action, yy_action_33)
+    T_LBRACE_CODE_RBRACE => Shift(yy_state_103)
+    NT_clause_action => Shift(yy_state_117)
+    NT_clause_action_opt => Shift(yy_state_118)
+    T_BAR | T_SEMI => Reduce(0, NT_clause_action_opt, yy_action_35)
     _ => Error
   }
 }
 
-// [53, clause_action → LBRACE_CODE_RBRACE •, BAR / SEMI]
-fn yy_state_113(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_clause_action, yy_action_57)
+// [53, clause_action_opt → clause_action •, BAR / SEMI]
+fn yy_state_117(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(1, NT_clause_action_opt, yy_action_59)
 }
 
-// [52, clause → item_list rule_prec clause_action •, BAR / SEMI]
-fn yy_state_114(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_clause, yy_action_58)
+// [52, clause → item_list rule_prec clause_action_opt •, BAR / SEMI]
+fn yy_state_118(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(3, NT_clause, yy_action_60)
 }
 
 // [50, clause_list → clause •, SEMI]
 // [51, clause_list → clause • BAR clause_list, SEMI]
-fn yy_state_115(_lookahead : YYSymbol) -> YYDecision {
+fn yy_state_119(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_BAR => Shift(yy_state_116)
-    T_SEMI => Reduce(1, NT_clause_list, yy_action_27)
+    T_BAR => Shift(yy_state_120)
+    T_SEMI => Reduce(1, NT_clause_list, yy_action_29)
     _ => Error
   }
 }
@@ -2083,52 +2153,52 @@ fn yy_state_115(_lookahead : YYSymbol) -> YYDecision {
 // [50, clause_list → • clause, SEMI]
 // [51, clause_list → • clause BAR clause_list, SEMI]
 // [51, clause_list → clause BAR • clause_list, SEMI]
-// [52, clause → • item_list rule_prec clause_action, BAR / SEMI]
-// [57, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [58, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [59, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [60, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [61, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [62, term → • symbol LPAREN nonempty_comma_term_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [63, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [68, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
-fn yy_state_116(_lookahead : YYSymbol) -> YYDecision {
+// [52, clause → • item_list rule_prec clause_action_opt, BAR / SEMI]
+// [58, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [59, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [60, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [61, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [62, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [63, term → • symbol LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [64, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [71, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
+fn yy_state_120(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_STRING => Shift(yy_state_95)
     NT_symbol => Shift(yy_state_96)
-    T_IDENT => Shift(yy_state_103)
-    NT_term => Shift(yy_state_106)
-    NT_item => Shift(yy_state_107)
-    NT_item_list => Shift(yy_state_109)
-    NT_clause => Shift(yy_state_115)
-    NT_clause_list => Shift(yy_state_117)
-    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_14)
+    T_IDENT => Shift(yy_state_104)
+    NT_item => Shift(yy_state_108)
+    NT_term => Shift(yy_state_109)
+    NT_item_list => Shift(yy_state_113)
+    NT_clause => Shift(yy_state_119)
+    NT_clause_list => Shift(yy_state_121)
+    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_54)
     _ => Error
   }
 }
 
 // [51, clause_list → clause BAR clause_list •, SEMI]
-fn yy_state_117(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(3, NT_clause_list, yy_action_32)
+fn yy_state_121(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(3, NT_clause_list, yy_action_34)
 }
 
 // [24, rule_no_modifiers → symbol opt_rule_generic_params LPAREN nonempty_rule_param_list RPAREN opt_rule_return_type COLON clause_list • SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-fn yy_state_118(_lookahead : YYSymbol) -> YYDecision {
+fn yy_state_122(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_SEMI => Shift(yy_state_119)
+    T_SEMI => Shift(yy_state_123)
     _ => Error
   }
 }
 
 // [24, rule_no_modifiers → symbol opt_rule_generic_params LPAREN nonempty_rule_param_list RPAREN opt_rule_return_type COLON clause_list SEMI •, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-fn yy_state_119(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(9, NT_rule_no_modifiers, yy_action_10)
+fn yy_state_123(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(9, NT_rule_no_modifiers, yy_action_11)
 }
 
 // [23, rule_no_modifiers → symbol opt_rule_return_type • COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-fn yy_state_120(_lookahead : YYSymbol) -> YYDecision {
+fn yy_state_124(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_COLON => Shift(yy_state_121)
+    T_COLON => Shift(yy_state_125)
     _ => Error
   }
 }
@@ -2136,64 +2206,64 @@ fn yy_state_120(_lookahead : YYSymbol) -> YYDecision {
 // [23, rule_no_modifiers → symbol opt_rule_return_type COLON • clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [50, clause_list → • clause, SEMI]
 // [51, clause_list → • clause BAR clause_list, SEMI]
-// [52, clause → • item_list rule_prec clause_action, BAR / SEMI]
-// [57, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [58, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [59, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [60, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [61, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [62, term → • symbol LPAREN nonempty_comma_term_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [63, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
-// [68, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
-fn yy_state_121(_lookahead : YYSymbol) -> YYDecision {
+// [52, clause → • item_list rule_prec clause_action_opt, BAR / SEMI]
+// [58, item_list → • item item_list, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [59, item_list → •, LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [60, item → • term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [61, item → • IDENT EQ term, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [62, term → • symbol, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [63, term → • symbol LPAREN nonempty_comma_rule_arg_list RPAREN, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [64, term → • STRING, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / BAR / SEMI]
+// [71, symbol → • IDENT, IDENT / STRING / LBRACE_CODE_RBRACE / PERCENT_PREC / LPAREN / BAR / SEMI]
+fn yy_state_125(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_STRING => Shift(yy_state_95)
     NT_symbol => Shift(yy_state_96)
-    T_IDENT => Shift(yy_state_103)
-    NT_term => Shift(yy_state_106)
-    NT_item => Shift(yy_state_107)
-    NT_item_list => Shift(yy_state_109)
-    NT_clause => Shift(yy_state_115)
-    NT_clause_list => Shift(yy_state_122)
-    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_14)
+    T_IDENT => Shift(yy_state_104)
+    NT_item => Shift(yy_state_108)
+    NT_term => Shift(yy_state_109)
+    NT_item_list => Shift(yy_state_113)
+    NT_clause => Shift(yy_state_119)
+    NT_clause_list => Shift(yy_state_126)
+    T_LBRACE_CODE_RBRACE | T_PERCENT_PREC | T_BAR | T_SEMI => Reduce(0, NT_item_list, yy_action_54)
     _ => Error
   }
 }
 
 // [23, rule_no_modifiers → symbol opt_rule_return_type COLON clause_list • SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-fn yy_state_122(_lookahead : YYSymbol) -> YYDecision {
+fn yy_state_126(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_SEMI => Shift(yy_state_123)
+    T_SEMI => Shift(yy_state_127)
     _ => Error
   }
 }
 
 // [23, rule_no_modifiers → symbol opt_rule_return_type COLON clause_list SEMI •, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-fn yy_state_123(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(5, NT_rule_no_modifiers, yy_action_19)
+fn yy_state_127(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(5, NT_rule_no_modifiers, yy_action_20)
 }
 
 // [22, rule → PERCENT_INLINE • rule_no_modifiers, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [23, rule_no_modifiers → • symbol opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [24, rule_no_modifiers → • symbol opt_rule_generic_params LPAREN nonempty_rule_param_list RPAREN opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-// [68, symbol → • IDENT, LBRACKET / LPAREN / ARROW / COLON]
-fn yy_state_124(_lookahead : YYSymbol) -> YYDecision {
+// [71, symbol → • IDENT, LBRACKET / LPAREN / ARROW / COLON]
+fn yy_state_128(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
     NT_symbol => Shift(yy_state_73)
-    NT_rule_no_modifiers => Shift(yy_state_125)
+    NT_rule_no_modifiers => Shift(yy_state_129)
     _ => Error
   }
 }
 
 // [22, rule → PERCENT_INLINE rule_no_modifiers •, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-fn yy_state_125(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_rule, yy_action_28)
+fn yy_state_129(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(2, NT_rule, yy_action_30)
 }
 
 // [21, rule → rule_no_modifiers •, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-fn yy_state_126(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_rule, yy_action_20)
+fn yy_state_130(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(1, NT_rule, yy_action_21)
 }
 
 // [19, rule_list → • rule, EOF / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF]
@@ -2204,60 +2274,60 @@ fn yy_state_126(_lookahead : YYSymbol) -> YYDecision {
 // [22, rule → • PERCENT_INLINE rule_no_modifiers, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [23, rule_no_modifiers → • symbol opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
 // [24, rule_no_modifiers → • symbol opt_rule_generic_params LPAREN nonempty_rule_param_list RPAREN opt_rule_return_type COLON clause_list SEMI, EOF / IDENT / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF / PERCENT_INLINE]
-// [68, symbol → • IDENT, LBRACKET / LPAREN / ARROW / COLON]
-fn yy_state_127(_lookahead : YYSymbol) -> YYDecision {
+// [71, symbol → • IDENT, LBRACKET / LPAREN / ARROW / COLON]
+fn yy_state_131(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
     T_IDENT => Shift(yy_state_40)
     NT_symbol => Shift(yy_state_73)
-    T_PERCENT_INLINE => Shift(yy_state_124)
-    NT_rule_no_modifiers => Shift(yy_state_126)
-    NT_rule => Shift(yy_state_127)
-    NT_rule_list => Shift(yy_state_128)
-    T_EOF | T_PERCENT_LBRACE_CODE_PERCENT_RBRACE | T_PERCENT_PERCENT_CODE_EOF => Reduce(1, NT_rule_list, yy_action_7)
+    T_PERCENT_INLINE => Shift(yy_state_128)
+    NT_rule_no_modifiers => Shift(yy_state_130)
+    NT_rule => Shift(yy_state_131)
+    NT_rule_list => Shift(yy_state_132)
+    T_EOF | T_PERCENT_LBRACE_CODE_PERCENT_RBRACE | T_PERCENT_PERCENT_CODE_EOF => Reduce(1, NT_rule_list, yy_action_8)
     _ => Error
   }
 }
 
 // [20, rule_list → rule rule_list •, EOF / PERCENT_LBRACE_CODE_PERCENT_RBRACE / PERCENT_PERCENT_CODE_EOF]
-fn yy_state_128(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(2, NT_rule_list, yy_action_55)
+fn yy_state_132(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(2, NT_rule_list, yy_action_57)
 }
 
 // [0, spec → header decl_list PERCENT_PERCENT rule_list • trailer EOF, $]
 // [3, trailer → • PERCENT_LBRACE_CODE_PERCENT_RBRACE, EOF]
 // [4, trailer → • PERCENT_PERCENT_CODE_EOF, EOF]
 // [5, trailer → •, EOF]
-fn yy_state_129(_lookahead : YYSymbol) -> YYDecision {
+fn yy_state_133(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_PERCENT_PERCENT_CODE_EOF => Shift(yy_state_130)
-    T_PERCENT_LBRACE_CODE_PERCENT_RBRACE => Shift(yy_state_131)
-    NT_trailer => Shift(yy_state_132)
-    T_EOF => Reduce(0, NT_trailer, yy_action_17)
+    T_PERCENT_PERCENT_CODE_EOF => Shift(yy_state_134)
+    T_PERCENT_LBRACE_CODE_PERCENT_RBRACE => Shift(yy_state_135)
+    NT_trailer => Shift(yy_state_136)
+    T_EOF => Reduce(0, NT_trailer, yy_action_18)
     _ => Error
   }
 }
 
 // [4, trailer → PERCENT_PERCENT_CODE_EOF •, EOF]
-fn yy_state_130(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_trailer, yy_action_39)
+fn yy_state_134(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(1, NT_trailer, yy_action_41)
 }
 
 // [3, trailer → PERCENT_LBRACE_CODE_PERCENT_RBRACE •, EOF]
-fn yy_state_131(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(1, NT_trailer, yy_action_49)
+fn yy_state_135(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(1, NT_trailer, yy_action_51)
 }
 
 // [0, spec → header decl_list PERCENT_PERCENT rule_list trailer • EOF, $]
-fn yy_state_132(_lookahead : YYSymbol) -> YYDecision {
+fn yy_state_136(_lookahead : YYSymbol) -> YYDecision {
   match _lookahead {
-    T_EOF => Shift(yy_state_133)
+    T_EOF => Shift(yy_state_137)
     _ => Error
   }
 }
 
 // [0, spec → header decl_list PERCENT_PERCENT rule_list trailer EOF •, $]
-fn yy_state_133(_lookahead : YYSymbol) -> YYDecision {
-  ReduceNoLookahead(6, NT_spec, yy_action_44)
+fn yy_state_137(_lookahead : YYSymbol) -> YYDecision {
+  ReduceNoLookahead(6, NT_spec, yy_action_46)
 }
 
 fn yy_parse[T](
diff --git a/src/lib/parser/parser.mbt.map.json b/src/lib/parser/parser.mbt.map.json
index 37a4eb8..f646fc2 100644
--- a/src/lib/parser/parser.mbt.map.json
+++ b/src/lib/parser/parser.mbt.map.json
@@ -3,661 +3,691 @@
     {
       "source": "parser.mbty",
       "original_offset": 1362,
-      "generated_offset": 6417,
+      "generated_offset": 6458,
       "length": 23
     },
     {
       "source": "parser.mbty",
       "original_offset": 1667,
-      "generated_offset": 6674,
+      "generated_offset": 6715,
       "length": 50
     },
     {
       "source": "parser.mbty",
       "original_offset": 2413,
-      "generated_offset": 6957,
+      "generated_offset": 6998,
       "length": 51
     },
+    {
+      "source": "parser.mbty",
+      "original_offset": 6535,
+      "generated_offset": 7292,
+      "length": 27
+    },
     {
       "source": "parser.mbty",
       "original_offset": 4404,
-      "generated_offset": 7187,
+      "generated_offset": 7498,
       "length": 17
     },
     {
       "source": "parser.mbty",
       "original_offset": 4423,
-      "generated_offset": 7212,
+      "generated_offset": 7523,
       "length": 5
     },
     {
       "source": "parser.mbty",
       "original_offset": 4430,
-      "generated_offset": 7225,
+      "generated_offset": 7536,
       "length": 8
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5937,
-      "generated_offset": 7454,
-      "length": 18
-    },
-    {
-      "source": "parser.mbty",
-      "original_offset": 5957,
-      "generated_offset": 7480,
-      "length": 13
+      "original_offset": 5931,
+      "generated_offset": 7707,
+      "length": 16
     },
     {
       "source": "parser.mbty",
       "original_offset": 5790,
-      "generated_offset": 7701,
-      "length": 38
+      "generated_offset": 7888,
+      "length": 30
     },
     {
       "source": "parser.mbty",
-      "original_offset": 6383,
-      "generated_offset": 7903,
-      "length": 7
+      "original_offset": 6367,
+      "generated_offset": 8151,
+      "length": 23
     },
     {
       "source": "parser.mbty",
       "original_offset": 2519,
-      "generated_offset": 8084,
+      "generated_offset": 8348,
       "length": 17
     },
     {
       "source": "parser.mbty",
       "original_offset": 3959,
-      "generated_offset": 8272,
+      "generated_offset": 8536,
       "length": 11
     },
     {
       "source": "parser.mbty",
       "original_offset": 3972,
-      "generated_offset": 8291,
+      "generated_offset": 8555,
       "length": 2
     },
     {
       "source": "parser.mbty",
-      "original_offset": 6315,
-      "generated_offset": 8536,
-      "length": 27
+      "original_offset": 6286,
+      "generated_offset": 8732,
+      "length": 17
     },
     {
       "source": "parser.mbty",
       "original_offset": 3096,
-      "generated_offset": 8973,
+      "generated_offset": 9159,
       "length": 126
     },
     {
       "source": "parser.mbty",
       "original_offset": 4160,
-      "generated_offset": 9380,
+      "generated_offset": 9566,
       "length": 24
     },
     {
       "source": "parser.mbty",
       "original_offset": 4186,
-      "generated_offset": 9412,
+      "generated_offset": 9598,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 4190,
-      "generated_offset": 9422,
+      "generated_offset": 9608,
       "length": 14
     },
     {
       "source": "parser.mbty",
       "original_offset": 4206,
-      "generated_offset": 9444,
+      "generated_offset": 9630,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 1551,
-      "generated_offset": 9637,
+      "generated_offset": 9823,
       "length": 43
     },
     {
       "source": "parser.mbty",
       "original_offset": 4357,
-      "generated_offset": 9850,
+      "generated_offset": 10036,
       "length": 18
     },
     {
       "source": "parser.mbty",
       "original_offset": 4377,
-      "generated_offset": 9876,
+      "generated_offset": 10062,
       "length": 6
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5680,
-      "generated_offset": 10024,
-      "length": 5
+      "original_offset": 5714,
+      "generated_offset": 10320,
+      "length": 23
     },
     {
       "source": "parser.mbty",
-      "original_offset": 6074,
-      "generated_offset": 10204,
-      "length": 17
+      "original_offset": 6058,
+      "generated_offset": 10506,
+      "length": 14
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5542,
-      "generated_offset": 10388,
-      "length": 14
+      "original_offset": 5431,
+      "generated_offset": 10773,
+      "length": 92
+    },
+    {
+      "source": "parser.mbty",
+      "original_offset": 5532,
+      "generated_offset": 10875,
+      "length": 7
+    },
+    {
+      "source": "parser.mbty",
+      "original_offset": 5546,
+      "generated_offset": 10890,
+      "length": 5
     },
     {
       "source": "parser.mbty",
       "original_offset": 1274,
-      "generated_offset": 10524,
+      "generated_offset": 11017,
       "length": 6
     },
     {
       "source": "parser.mbty",
       "original_offset": 1112,
-      "generated_offset": 10693,
+      "generated_offset": 11186,
       "length": 12
     },
     {
       "source": "parser.mbty",
       "original_offset": 2818,
-      "generated_offset": 10982,
+      "generated_offset": 11475,
       "length": 110
     },
     {
       "source": "parser.mbty",
       "original_offset": 2639,
-      "generated_offset": 11256,
+      "generated_offset": 11749,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 2642,
-      "generated_offset": 11265,
+      "generated_offset": 11758,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 4740,
-      "generated_offset": 11438,
+      "generated_offset": 11931,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 4743,
-      "generated_offset": 11447,
+      "generated_offset": 11940,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 2145,
-      "generated_offset": 11639,
+      "generated_offset": 12132,
       "length": 30
     },
     {
       "source": "parser.mbty",
       "original_offset": 1131,
-      "generated_offset": 11791,
+      "generated_offset": 12284,
       "length": 6
     },
     {
       "source": "parser.mbty",
-      "original_offset": 6242,
-      "generated_offset": 11978,
-      "length": 19
+      "original_offset": 6158,
+      "generated_offset": 12525,
+      "length": 50
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5650,
-      "generated_offset": 12249,
-      "length": 23
+      "original_offset": 6603,
+      "generated_offset": 12740,
+      "length": 7
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5563,
-      "generated_offset": 12396,
+      "original_offset": 5627,
+      "generated_offset": 12871,
       "length": 6
     },
+    {
+      "source": "parser.mbty",
+      "original_offset": 5606,
+      "generated_offset": 13044,
+      "length": 14
+    },
     {
       "source": "parser.mbty",
       "original_offset": 5015,
-      "generated_offset": 12583,
+      "generated_offset": 13239,
       "length": 19
     },
     {
       "source": "parser.mbty",
       "original_offset": 2678,
-      "generated_offset": 12766,
+      "generated_offset": 13422,
       "length": 5
     },
     {
       "source": "parser.mbty",
       "original_offset": 2685,
-      "generated_offset": 12779,
+      "generated_offset": 13435,
       "length": 17
     },
     {
       "source": "parser.mbty",
       "original_offset": 4671,
-      "generated_offset": 13030,
+      "generated_offset": 13686,
       "length": 24
     },
     {
       "source": "parser.mbty",
       "original_offset": 4697,
-      "generated_offset": 13062,
+      "generated_offset": 13718,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 4701,
-      "generated_offset": 13072,
+      "generated_offset": 13728,
       "length": 14
     },
     {
       "source": "parser.mbty",
       "original_offset": 3593,
-      "generated_offset": 13402,
+      "generated_offset": 14058,
       "length": 7
     },
     {
       "source": "parser.mbty",
       "original_offset": 3602,
-      "generated_offset": 13417,
+      "generated_offset": 14073,
       "length": 7
     },
     {
       "source": "parser.mbty",
       "original_offset": 3611,
-      "generated_offset": 13432,
+      "generated_offset": 14088,
       "length": 4
     },
     {
       "source": "parser.mbty",
       "original_offset": 3617,
-      "generated_offset": 13444,
+      "generated_offset": 14100,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 4483,
-      "generated_offset": 13678,
+      "generated_offset": 14334,
       "length": 18
     },
     {
       "source": "parser.mbty",
       "original_offset": 4503,
-      "generated_offset": 13704,
+      "generated_offset": 14360,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 4507,
-      "generated_offset": 13714,
+      "generated_offset": 14370,
       "length": 13
     },
     {
       "source": "parser.mbty",
       "original_offset": 5083,
-      "generated_offset": 13971,
+      "generated_offset": 14627,
       "length": 27
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5439,
-      "generated_offset": 14183,
+      "original_offset": 5317,
+      "generated_offset": 14839,
       "length": 22
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5470,
-      "generated_offset": 14215,
+      "original_offset": 5348,
+      "generated_offset": 14871,
       "length": 7
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5484,
-      "generated_offset": 14230,
+      "original_offset": 5362,
+      "generated_offset": 14886,
       "length": 3
     },
     {
       "source": "parser.mbty",
       "original_offset": 3859,
-      "generated_offset": 14476,
+      "generated_offset": 15132,
       "length": 6
     },
     {
       "source": "parser.mbty",
       "original_offset": 3867,
-      "generated_offset": 14490,
+      "generated_offset": 15146,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 3871,
-      "generated_offset": 14500,
+      "generated_offset": 15156,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 3289,
-      "generated_offset": 14672,
+      "generated_offset": 15328,
       "length": 13
     },
     {
       "source": "parser.mbty",
       "original_offset": 3396,
-      "generated_offset": 14881,
+      "generated_offset": 15537,
       "length": 7
     },
     {
       "source": "parser.mbty",
       "original_offset": 3405,
-      "generated_offset": 14896,
+      "generated_offset": 15552,
       "length": 14
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5990,
-      "generated_offset": 15073,
-      "length": 14
+      "original_offset": 6005,
+      "generated_offset": 15788,
+      "length": 18
+    },
+    {
+      "source": "parser.mbty",
+      "original_offset": 6025,
+      "generated_offset": 15814,
+      "length": 13
     },
     {
       "source": "parser.mbty",
       "original_offset": 4075,
-      "generated_offset": 15306,
+      "generated_offset": 16046,
       "length": 8
     },
     {
       "source": "parser.mbty",
       "original_offset": 4085,
-      "generated_offset": 15322,
+      "generated_offset": 16062,
       "length": 3
     },
     {
       "source": "parser.mbty",
       "original_offset": 4090,
-      "generated_offset": 15333,
+      "generated_offset": 16073,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 1255,
-      "generated_offset": 15498,
+      "generated_offset": 16238,
       "length": 12
     },
     {
       "source": "parser.mbty",
       "original_offset": 2307,
-      "generated_offset": 15701,
+      "generated_offset": 16441,
       "length": 34
     },
     {
       "source": "parser.mbty",
-      "original_offset": 6147,
-      "generated_offset": 15969,
-      "length": 23
+      "original_offset": 6106,
+      "generated_offset": 16639,
+      "length": 1
+    },
+    {
+      "source": "parser.mbty",
+      "original_offset": 6109,
+      "generated_offset": 16648,
+      "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 2224,
-      "generated_offset": 16183,
+      "generated_offset": 16840,
       "length": 31
     },
     {
       "source": "parser.mbty",
       "original_offset": 4266,
-      "generated_offset": 16386,
+      "generated_offset": 17043,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 4269,
-      "generated_offset": 16395,
+      "generated_offset": 17052,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 965,
-      "generated_offset": 16733,
+      "generated_offset": 17390,
       "length": 79
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5867,
-      "generated_offset": 16976,
-      "length": 16
+      "original_offset": 5854,
+      "generated_offset": 17678,
+      "length": 38
     },
     {
       "source": "parser.mbty",
       "original_offset": 1988,
-      "generated_offset": 17227,
+      "generated_offset": 17951,
       "length": 43
     },
     {
       "source": "parser.mbty",
       "original_offset": 4014,
-      "generated_offset": 17489,
+      "generated_offset": 18213,
       "length": 8
     },
     {
       "source": "parser.mbty",
       "original_offset": 4024,
-      "generated_offset": 17505,
+      "generated_offset": 18229,
       "length": 3
     },
     {
       "source": "parser.mbty",
       "original_offset": 4029,
-      "generated_offset": 17516,
+      "generated_offset": 18240,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 4573,
-      "generated_offset": 17760,
+      "generated_offset": 18484,
       "length": 17
     },
     {
       "source": "parser.mbty",
       "original_offset": 4592,
-      "generated_offset": 17785,
+      "generated_offset": 18509,
       "length": 5
     },
     {
       "source": "parser.mbty",
       "original_offset": 4599,
-      "generated_offset": 17798,
+      "generated_offset": 18522,
       "length": 4
     },
     {
       "source": "parser.mbty",
       "original_offset": 4605,
-      "generated_offset": 17810,
+      "generated_offset": 18534,
       "length": 13
     },
     {
       "source": "parser.mbty",
       "original_offset": 1206,
-      "generated_offset": 17986,
+      "generated_offset": 18710,
       "length": 12
     },
     {
       "source": "parser.mbty",
       "original_offset": 2074,
-      "generated_offset": 18170,
+      "generated_offset": 18894,
       "length": 23
     },
     {
       "source": "parser.mbty",
       "original_offset": 1392,
-      "generated_offset": 18336,
+      "generated_offset": 19060,
       "length": 5
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5726,
-      "generated_offset": 18507,
-      "length": 30
+      "original_offset": 5744,
+      "generated_offset": 19207,
+      "length": 5
     },
     {
       "source": "parser.mbty",
       "original_offset": 1471,
-      "generated_offset": 18728,
+      "generated_offset": 19403,
       "length": 31
     },
     {
       "source": "parser.mbty",
       "original_offset": 3672,
-      "generated_offset": 18889,
+      "generated_offset": 19564,
       "length": 4
     },
     {
       "source": "parser.mbty",
       "original_offset": 2573,
-      "generated_offset": 19127,
+      "generated_offset": 19802,
       "length": 23
     },
     {
       "source": "parser.mbty",
       "original_offset": 3925,
-      "generated_offset": 19322,
+      "generated_offset": 19997,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 3928,
-      "generated_offset": 19331,
+      "generated_offset": 20006,
       "length": 1
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5308,
-      "generated_offset": 19585,
-      "length": 96
-    },
-    {
-      "source": "parser.mbty",
-      "original_offset": 5413,
-      "generated_offset": 19691,
-      "length": 7
+      "original_offset": 5306,
+      "generated_offset": 20187,
+      "length": 1
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5427,
-      "generated_offset": 19706,
-      "length": 5
+      "original_offset": 5309,
+      "generated_offset": 20196,
+      "length": 1
     },
     {
       "source": "parser.mbty",
-      "original_offset": 5195,
-      "generated_offset": 19990,
+      "original_offset": 5199,
+      "generated_offset": 20476,
       "length": 47
     },
     {
       "source": "parser.mbty",
       "original_offset": 4827,
-      "generated_offset": 20225,
+      "generated_offset": 20711,
       "length": 22
     },
     {
       "source": "parser.mbty",
       "original_offset": 1868,
-      "generated_offset": 20504,
+      "generated_offset": 20990,
       "length": 48
     },
     {
       "source": "parser.mbty",
       "original_offset": 3801,
-      "generated_offset": 20735,
+      "generated_offset": 21221,
       "length": 6
     },
     {
       "source": "parser.mbty",
       "original_offset": 3809,
-      "generated_offset": 20749,
+      "generated_offset": 21235,
       "length": 7
     },
     {
       "source": "parser.mbty",
       "original_offset": 4919,
-      "generated_offset": 21012,
+      "generated_offset": 21498,
       "length": 33
     },
     {
       "source": "parser.mbty",
       "original_offset": 3515,
-      "generated_offset": 21314,
+      "generated_offset": 21800,
       "length": 7
     },
     {
       "source": "parser.mbty",
       "original_offset": 3524,
-      "generated_offset": 21329,
+      "generated_offset": 21815,
       "length": 9
     },
     {
       "source": "parser.mbty",
       "original_offset": 3535,
-      "generated_offset": 21346,
+      "generated_offset": 21832,
       "length": 2
     },
     {
       "source": "parser.mbty",
       "original_offset": 3309,
-      "generated_offset": 21474,
+      "generated_offset": 21960,
       "length": 6
     },
     {
       "source": "parser.mbty",
       "original_offset": 3446,
-      "generated_offset": 21723,
+      "generated_offset": 22209,
       "length": 7
     },
     {
       "source": "parser.mbty",
       "original_offset": 3455,
-      "generated_offset": 21738,
+      "generated_offset": 22224,
       "length": 7
     },
     {
       "source": "parser.mbty",
       "original_offset": 3464,
-      "generated_offset": 21753,
+      "generated_offset": 22239,
       "length": 9
     },
     {
       "source": "parser.mbty",
       "original_offset": 3717,
-      "generated_offset": 21952,
+      "generated_offset": 22438,
       "length": 1
     },
     {
       "source": "parser.mbty",
       "original_offset": 3720,
-      "generated_offset": 21961,
+      "generated_offset": 22447,
       "length": 12
     },
     {
       "source": "parser.mbty",
       "original_offset": 1760,
-      "generated_offset": 22186,
+      "generated_offset": 22672,
       "length": 41
     },
+    {
+      "source": "parser.mbty",
+      "original_offset": 6462,
+      "generated_offset": 22894,
+      "length": 19
+    },
     {
       "source": "parser.mbty",
       "original_offset": 4299,
-      "generated_offset": 22399,
+      "generated_offset": 23085,
       "length": 8
     },
     {
       "source": "parser.mbty",
       "original_offset": 4309,
-      "generated_offset": 22415,
+      "generated_offset": 23101,
       "length": 2
     }
   ]
diff --git a/src/lib/parser/parser.mbty b/src/lib/parser/parser.mbty
index 70e88a8..74ecd11 100644
--- a/src/lib/parser/parser.mbty
+++ b/src/lib/parser/parser.mbty
@@ -144,15 +144,19 @@ clause_list -> @immut/list.T[Clause]
   ;
 
 clause -> Clause
-  : item_list=item_list prec=rule_prec action=clause_action { { items: item_list.to_array(), prec, action } }
+  : item_list=item_list prec=rule_prec action=clause_action_opt { { items: item_list.to_array(), prec, action } }
+  ;
+
+clause_action_opt -> ClauseAction
+  : clause_action { $1 }
+  | { { code: None, start: $startpos, end: $endpos } }
   ;
 
 clause_action -> ClauseAction
   : code=LBRACE_CODE_RBRACE {
-      let (code, utf8_pos, subst) = code
-      { code: Some({ code, utf8_pos, subst }), start: $startpos, end: $endpos }
+    let (code, utf8_pos, subst) = code
+    { code: Some({ code, utf8_pos, subst }), start: $startpos, end: $endpos }
   }
-  | { { code: None, start: $startpos, end: $endpos } }
   ;
 
 rule_prec -> Symbol?
@@ -172,13 +176,18 @@ item -> ClauseItem
 
 term -> Term
   : symbol=symbol { Symbol(symbol) }
-  | symbol=symbol "(" nonempty_comma_term_list ")" { RuleCall(symbol, $3.to_array()) }
+  | symbol=symbol "(" nonempty_comma_rule_arg_list ")" { RuleCall(symbol, $3.to_array()) }
   | image=STRING { Image(image) }
   ;
 
-nonempty_comma_term_list -> @immut/list.T[Term]
-  : term=term { Cons(term, Nil) }
-  | term=term "," term_list=nonempty_comma_term_list { Cons(term, term_list) }
+rule_arg -> Term
+  : term { $1 }
+  | item_list=item_list action=clause_action { AnonmousInlineRule(item_list.to_array(), action) }
+  ;
+
+nonempty_comma_rule_arg_list -> @immut/list.T[Term]
+  : term=rule_arg { Cons(term, Nil) }
+  | term=rule_arg "," term_list=nonempty_comma_rule_arg_list { Cons(term, term_list) }
   ;
 
 nonempty_symbol_list -> @immut/list.T[Symbol]
diff --git a/src/lib/parser/test/parser_spec_src.mbt b/src/lib/parser/test/parser_spec_src.mbt
index 59d2b8b..8953210 100644
--- a/src/lib/parser/test/parser_spec_src.mbt
+++ b/src/lib/parser/test/parser_spec_src.mbt
@@ -148,15 +148,19 @@ let parser_spec_src : String =
   #|  ;
   #|
   #|clause -> Clause
-  #|  : item_list=item_list prec=rule_prec action=clause_action { { items: item_list.to_array(), prec, action } }
+  #|  : item_list=item_list prec=rule_prec action=clause_action_opt { { items: item_list.to_array(), prec, action } }
+  #|  ;
+  #|
+  #|clause_action_opt -> ClauseAction
+  #|  : clause_action { $1 }
+  #|  | { { code: None, start: $startpos, end: $endpos } }
   #|  ;
   #|
   #|clause_action -> ClauseAction
   #|  : code=LBRACE_CODE_RBRACE {
-  #|      let (code, utf8_pos, subst) = code
-  #|      { code: Some({ code, utf8_pos, subst }), start: $startpos, end: $endpos }
+  #|    let (code, utf8_pos, subst) = code
+  #|    { code: Some({ code, utf8_pos, subst }), start: $startpos, end: $endpos }
   #|  }
-  #|  | { { code: None, start: $startpos, end: $endpos } }
   #|  ;
   #|
   #|rule_prec -> Symbol?
@@ -176,13 +180,18 @@ let parser_spec_src : String =
   #|
   #|term -> Term
   #|  : symbol=symbol { Symbol(symbol) }
-  #|  | symbol=symbol "(" nonempty_comma_term_list ")" { RuleCall(symbol, $3.to_array()) }
+  #|  | symbol=symbol "(" nonempty_comma_rule_arg_list ")" { RuleCall(symbol, $3.to_array()) }
   #|  | image=STRING { Image(image) }
   #|  ;
   #|
-  #|nonempty_comma_term_list -> @immut/list.T[Term]
-  #|  : term=term { Cons(term, Nil) }
-  #|  | term=term "," term_list=nonempty_comma_term_list { Cons(term, term_list) }
+  #|rule_arg -> Term
+  #|  : term { $1 }
+  #|  | item_list=item_list action=clause_action { AnonmousInlineRule(item_list.to_array(), action) }
+  #|  ;
+  #|
+  #|nonempty_comma_rule_arg_list -> @immut/list.T[Term]
+  #|  : term=rule_arg { Cons(term, Nil) }
+  #|  | term=rule_arg "," term_list=nonempty_comma_rule_arg_list { Cons(term, term_list) }
   #|  ;
   #|
   #|nonempty_symbol_list -> @immut/list.T[Symbol]