v0.9.5

Author: yayanyang

CHANGELOG.md

@@ -8,6 +8,10 @@ This project adheres to [Semantic Versioning](https://semver.org).
 Note: In this file, do not use the hard wrap in the middle of a sentence for compatibility with GitHub comment style markdown rendering.
 -->
 
+## [0.9.5] - 2025-07-02
+
+- Derive: syntax add `try_filter` attribute.
+
 ## [0.9.4] - 2025-07-02
 
 - ErrorKind: add impl `ToSpan`.

core/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2024"
 license = "MIT"
 name = "parserc"
 repository = "https://github.com/styles-lab/parserc"
-version = "0.9.3"
+version = "0.9.5"
 
 [dependencies]
 memchr = "^2.7"

core/src/errors.rs

@@ -70,20 +70,20 @@ impl<T, I, E> MapFatal for Result<T, I, E> {
 }
 
 /// An extension trait for `std::result::Result<(T, I), ControlFlow<E>>`
-pub trait MapError<E1, E2> {
+pub trait MapError<E> {
     type Output;
     /// map underlying `ControlFlow`
     fn map_control_flow_err<F>(self, f: F) -> Self::Output
     where
-        F: FnOnce(E1) -> E2;
+        F: FnOnce(E) -> E;
 }
 
-impl<T, I, E1, E2> MapError<E1, E2> for Result<T, I, E1> {
-    type Output = Result<T, I, E2>;
+impl<T, I, E> MapError<E> for Result<T, I, E> {
+    type Output = Result<T, I, E>;
 
     fn map_control_flow_err<F>(self, f: F) -> Self::Output
     where
-        F: FnOnce(E1) -> E2,
+        F: FnOnce(E) -> E,
     {
         match self {
             Err(ControlFlow::Fatal(err)) => Err(ControlFlow::Fatal(f(err))),
@@ -116,3 +116,23 @@ impl<T1, T2, I, E> Map<T1, T2> for Result<T1, I, E> {
         }
     }
 }
+
+/// An extension trait for `std::result::Result<(T, I), ControlFlow<E>>`
+pub trait TryFilter<T, I, E> {
+    /// map underlying `ControlFlow`
+    fn try_filter_control_flow<F>(self, f: F) -> Result<T, I, E>
+    where
+        F: FnOnce(T) -> std::result::Result<T, ControlFlow<E>>;
+}
+
+impl<T, I, E> TryFilter<T, I, E> for Result<T, I, E> {
+    fn try_filter_control_flow<F>(self, f: F) -> Result<T, I, E>
+    where
+        F: FnOnce(T) -> std::result::Result<T, ControlFlow<E>>,
+    {
+        match self {
+            Ok((t, i)) => f(t).map(|t| (t, i)),
+            Err(err) => Err(err),
+        }
+    }
+}

derive/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2024"
 license = "MIT"
 name = "parserc-derive"
 repository = "https://github.com/styles-lab/parserc"
-version = "0.9.3"
+version = "0.9.5"
 
 [dependencies]
 proc-macro2 = "^1"

derive/src/lib.rs

@@ -18,7 +18,7 @@ pub fn tokens(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 }
 
 /// Derive `Syntax` trait for `structs/enums`.
-#[proc_macro_derive(Syntax, attributes(syntax, fatal, from, map_err))]
+#[proc_macro_derive(Syntax, attributes(syntax, fatal, from, map_err, try_filter))]
 pub fn derive_syntax_trait(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     syntax::derive_syntax_trait(input)
 }

derive/src/syntax.rs

@@ -109,6 +109,7 @@ struct Field {
     ident: Ident,
     from_ty: Option<Type>,
     map_err: Option<Expr>,
+    try_filter: Option<Expr>,
     fatal: bool,
 }
 
@@ -120,6 +121,7 @@ impl TryFrom<(usize, &syn::Field)> for Field {
         let mut fatal = false;
         let mut from_ty = None;
         let mut map_err_fn = None;
+        let mut try_filter = None;
 
         for attr in &field.attrs {
             let path = attr.path();
@@ -130,6 +132,9 @@ impl TryFrom<(usize, &syn::Field)> for Field {
             } else if path.is_ident("map_err") {
                 let expr: Expr = attr.parse_args()?;
                 map_err_fn = Some(expr);
+            } else if path.is_ident("try_filter") {
+                let expr: Expr = attr.parse_args()?;
+                try_filter = Some(expr);
             } else if path.is_ident("fatal") {
                 fatal = true;
             }
@@ -140,12 +145,14 @@ impl TryFrom<(usize, &syn::Field)> for Field {
                 ident: ident.clone(),
                 from_ty,
                 map_err: map_err_fn,
+                try_filter,
                 fatal,
             }),
             None => Ok(Self {
                 ident: format_ident!("v_{}", index),
                 from_ty,
                 map_err: map_err_fn,
+                try_filter,
                 fatal,
             }),
         }
@@ -192,8 +199,13 @@ fn derive_syntax_for_enum(item: &ItemEnum) -> Result<proc_macro::TokenStream> {
                 .as_ref()
                 .map(|expr| quote! { .map_control_flow_err(#expr) });
 
+            let try_filter = field
+                .try_filter
+                .as_ref()
+                .map(|expr| quote! { .try_filter_control_flow(#expr) });
+
             quote! {
-                let (#ident,input) = input.parse() #from_ty #map_err #fatal ?;
+                let (#ident,input) = input.parse() #from_ty #map_err #try_filter #fatal ?;
             }
         });
 
@@ -244,6 +256,7 @@ fn derive_syntax_for_enum(item: &ItemEnum) -> Result<proc_macro::TokenStream> {
             fn parse(input: #ty_input) -> parserc::errors::Result<Self, #ty_input, #ty_error> {
                 use parserc::parser::Parser;
                 use parserc::errors::Map as _;
+                use parserc::errors::TryFilter as _;
                 use parserc::errors::MapFatal as _;
                 use parserc::errors::MapError as _;
 
@@ -294,8 +307,13 @@ fn derive_syntax_for_struct(item: &ItemStruct) -> Result<proc_macro::TokenStream
             .as_ref()
             .map(|expr| quote! { .map_control_flow_err(#expr) });
 
+        let try_filter = field
+            .try_filter
+            .as_ref()
+            .map(|expr| quote! { .try_filter_control_flow(#expr) });
+
         quote! {
-            let (#ident,input) = input.parse() #from_ty #map_err #fatal ?;
+            let (#ident,input) = input.parse() #from_ty #map_err #try_filter #fatal ?;
         }
     });
 
@@ -321,6 +339,7 @@ fn derive_syntax_for_struct(item: &ItemStruct) -> Result<proc_macro::TokenStream
             fn parse(input: #ty_input) -> parserc::errors::Result<Self, #ty_input, #ty_error> {
                 use parserc::parser::Parser;
                 use parserc::errors::Map as _;
+                use parserc::errors::TryFilter as _;
                 use parserc::errors::MapFatal as _;
                 use parserc::errors::MapError as _;