Implement basic cut operator

peg-macros/analysis.rs

@@ -166,7 +166,7 @@ impl<'a> LeftRecursionVisitor<'a> {
 
             LiteralExpr(_) | PatternExpr(_) | MethodExpr(_, _) | FailExpr(_) | MarkerExpr(_) => false,
 
-            PositionExpr => true,
+            PositionExpr | CutExpr => true,
         }
     }
 }
@@ -273,7 +273,7 @@ impl<'a> LoopNullabilityVisitor<'a> {
             }
 
             LiteralExpr(_) | PatternExpr(_) | MethodExpr(_, _) | FailExpr(_) | MarkerExpr(_) => false,
-            PositionExpr => true,
+            PositionExpr | CutExpr => true,
         }
     }
 }

peg-macros/ast.rs

@@ -90,6 +90,7 @@ pub enum Expr {
         levels: Vec<PrecedenceLevel>,
     },
     MarkerExpr(bool),
+    CutExpr,
 }
 
 impl Expr {

peg-macros/grammar.rustpeg

@@ -106,7 +106,8 @@ rule labeled() -> TaggedExpr
         { TaggedExpr{ name: label, expr: expression } }
 
 rule suffixed() -> SpannedExpr
-    = e:prefixed() sp:sp() "?" { OptionalExpr(Box::new(e)).at(sp) }
+    = sp:sp() "~>" { CutExpr.at(sp) }
+    / e:prefixed() sp:sp() "?" { OptionalExpr(Box::new(e)).at(sp) }
     / e:prefixed() sp:sp() "**" count:repeatcount() sep:primary() { Repeat { inner: Box::new(e), bound: count, sep: Some(Box::new(sep)) }.at(sp) }
     / e:prefixed() sp:sp() "++" sep:primary() { Repeat { inner: Box::new(e), bound: BoundedRepeat::Plus, sep: Some(Box::new(sep)) }.at(sp )}
     / e:prefixed() sp:sp() "*" count:repeatcount() { Repeat { inner: Box::new(e), bound: count, sep: None }.at(sp) }

peg-macros/translate.rs

@@ -435,6 +435,7 @@ fn ordered_choice(span: Span, mut rs: impl DoubleEndedIterator<Item = TokenStrea
             let __choice_res = #preferred;
             match __choice_res {
                 ::peg::RuleResult::Matched(__pos, __value) => ::peg::RuleResult::Matched(__pos, __value),
+                ::peg::RuleResult::Failed if __err_state.is_cut => ::peg::RuleResult::Failed, 
                 ::peg::RuleResult::Failed => #fallback
             }
         }}
@@ -1017,5 +1018,11 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS
         MarkerExpr { .. } => {
             report_error(span, "`@` is only allowed in `precedence!{}`".to_string())
         }
+        CutExpr => {
+            quote_spanned!{ span => {
+                __err_state.is_cut = true;
+                ::peg::RuleResult::Matched(__pos, __pos)
+            }}
+        }
     }
 }

peg-runtime/error.rs

@@ -79,6 +79,9 @@ pub struct ErrorState {
     /// Non-zero => yes, to support nested blocks.
     pub suppress_fail: usize,
 
+    /// Are we cut from other choices?
+    pub is_cut: bool,
+
     /// Are we reparsing after a failure? If so, compute and store expected set of all alternative expectations
     /// when we are at offset `max_err_pos`.
     pub reparsing_on_error: bool,
@@ -92,6 +95,7 @@ impl ErrorState {
         ErrorState {
             max_err_pos: initial_pos,
             suppress_fail: 0,
+            is_cut: false,
             reparsing_on_error: false,
             expected: ExpectedSet {
                 expected: BTreeSet::new(),

tests/run-pass/cut.rs

@@ -0,0 +1,16 @@
+extern crate peg;
+
+peg::parser!( grammar test_grammar() for str {
+    pub rule cut() -> Option<&'input str>
+        = "a" ending:$("a") {Some(ending)}
+        / "a" ~> ending:$("b") {Some(ending)}
+        / "a" ending:$("c") {Some(ending)}
+});
+
+use self::test_grammar::*;
+
+fn main() {
+    assert_eq!(cut("aa"), Ok(Some("a")));
+    assert_eq!(cut("ab"), Ok(Some("b")));
+    assert!(cut("ac").is_err());
+}