Parsa是一个函数式组合解析库。它专注于简洁的错误处理、模块化和可重用性，以及0拷贝字符串消费和回溯。

示例

让我们解析字符串"var = 123"。注意，示例将使用thiserror来最小化样板代码。首先，我们的结构和错误类型

use parsa::{ParserString, Parsable};
use parsa::builtins::*;
use thiserror::Error; //simple errors
use parsa::nevermore::FromNever; //From<Infallible> conversion
use std::num::ParseIntError;

struct Var {
    name: String,
    val: i32,
}
#[derive(Debug, Clone, Error, FromNever)]
enum VarErr {
    #[error("missing var name")]
    Empty(#[from] WordErr),
    #[error("missing \"=\"")]
    MissingEqual(#[from] TakeErr),
    #[error("error parsing number: {0}")]
    NumberParse(#[from] ParseIntError),
}
impl Parsable for Var {
    type Err = VarErr;
    fn parse(s: &mut ParserString) -> Result<Self, Self::Err> {
        todo!()
    }
}

我们首先需要解析变量的名称，我们可以使用word来做到这一点。我们还希望去除空白字符，因此我们可以使用带有after组合器的whitespace，因为我们不关心其输出。

let name = word
    .convert_err::<VarErr>() //explicitly set our target error type
                             //not always needed, but usually helps with inference
    .after(whitespace) //whitespace is infallible, so we dont need an explicit variant
                       //in our error type to coerce from it.
    .parse(s)?;

接下来，我们只想确保等号=出现在之后。

let _ = take("=").after(whitespace).parse(s)?; //coerces to MissingEqual

我们的最后一步是获取数字。我们再次使用word，但这次映射结果。

    let val = word
        .convert_err::<VarErr>() //will save headaches
        .and_then(|s| s.parse::<i32>())
        .parse(s)?;

现在我们可以构建我们的结构！

Ok(Var { name, val })

因为这个函数具有正确的签名，所以它可以与Parser中的任何方法一起使用。

let vars: Vec<Var> = Var::parse.many().parse(s)?;