我正在开发一个用Rust编写的小持续时间解析库，并使用nom库。在这个库中，我定义了一个second解析器组合子函数。它的职责是解析以文本格式表示秒的各种可接受格式。
pub fn duration(input: &str) -> IResult<&str, std::time::Duration> {
// Some code combining the various time format combinators
// to match the format "10 days, 8 hours, 7 minutes and 6 seconds"
}
pub fn seconds(input: &str) -> IResult<&str, u64> {
terminated(unsigned_integer_64, preceded(multispace0, second))(input)
}
fn second(input: &str) -> IResult<&str, &str> {
alt((
tag("seconds"),
tag("second"),
tag("secs"),
tag("sec"),
tag("s"),
))(input)
}
到目前为止，标记组合子的行为和我预期的一样。然而，我最近发现以下示例失败了，并且从定义上讲是失败的：
assert!(second("se").is_err())
事实上，该文件指出；输入数据将与标记组合子的参数进行比较，并返回与参数"匹配的输入部分；。
然而，正如我的示例所希望说明的那样，我希望实现的是，如果不能解析整个输入，那么某种类型的标记将失败。我研究了在解析输入后显式检查是否存在rest；并发现它会起作用。此外，还未成功探索使用complete和take组合子的一些风格来实现这一点。
解析"；精确匹配"；的一个单词，并在部分结果上失败(这将返回一个rest(？
您可以使用全消耗组合子，如果整个输入都被其子语法分析器消耗掉，则会成功：
// nom 6.1.2
use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::combinator::all_consuming;
use nom::IResult;
fn main() {
assert!(second("se").is_err());
}
fn second(input: &str) -> IResult<&str, &str> {
all_consuming(alt((
tag("seconds"),
tag("second"),
tag("secs"),
tag("sec"),
tag("s"),
)))(input)
}
更新
我想我误解了你原来的问题。也许这更符合你的需求。关键是你应该编写更小的解析器，然后将它们组合起来：
use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::character::complete::digit1;
use nom::combinator::all_consuming;
use nom::sequence::{terminated, tuple};
use nom::IResult;
#[derive(Debug)]
struct Time {
min: u32,
sec: u32,
}
fn main() {
//OK
let parsed = time("10 minutes, 5 seconds");
println!("{:?}", parsed);
//OK
let parsed = time("10 mins, 5 s");
println!("{:?}", parsed);
//Error -> although `min` is a valid tag, it would expect `, ` afterwards, instead of `ts`
let parsed = time("10 mints, 5 s");
println!("{:?}", parsed);
//Error -> there must not be anything left after "5 s"
let parsed = time("10 mins, 5 s, ");
println!("{:?}", parsed);
// Error -> although it starts with `sec` which is a valid tag, it will fail, because it would expect EOF
let parsed = time("10 min, 5 sections");
println!("{:?}", parsed);
}
fn time(input: &str) -> IResult<&str, Time> {
// parse the minutes section and **expect** a delimiter, because there **must** be another section afterwards
let (rem, min) = terminated(minutes_section, delimiter)(input)?;
// parse the minutes section and **expect** EOF - i.e. there should not be any input left to parse
let (rem, sec) = all_consuming(seconds_section)(rem)?;
// rem should be empty slice
IResult::Ok((rem, Time { min, sec }))
}
// This function combines several parsers to parse the minutes section:
// NUMBER[sep]TAG-MINUTES
fn minutes_section(input: &str) -> IResult<&str, u32> {
let (rem, (min, _sep, _tag)) = tuple((number, separator, minutes))(input)?;
IResult::Ok((rem, min))
}
// This function combines several parsers to parse the seconds section:
// NUMBER[sep]TAG-SECONDS
fn seconds_section(input: &str) -> IResult<&str, u32> {
let (rem, (sec, _sep, _tag)) = tuple((number, separator, seconds))(input)?;
IResult::Ok((rem, sec))
}
fn number(input: &str) -> IResult<&str, u32> {
digit1(input).map(|(remaining, number)| {
// it can panic if the string represents a number
// that does not fit into u32
let n = number.parse().unwrap();
(remaining, n)
})
}
fn minutes(input: &str) -> IResult<&str, &str> {
alt((
tag("minutes"),
tag("minute"),
tag("mins"),
tag("min"),
tag("m"),
))(input)
}
fn seconds(input: &str) -> IResult<&str, &str> {
alt((
tag("seconds"),
tag("second"),
tag("secs"),
tag("sec"),
tag("s"),
))(input)
}
// This function parses the separator between the number and the tag:
//N<separator>tag -> 5[sep]minutes
fn separator(input: &str) -> IResult<&str, &str> {
tag(" ")(input)
}
// This function parses the delimiter between the sections:
// X minutes<delimiter>Y seconds -> 1 min[delimiter]2 sec
fn delimiter(input: &str) -> IResult<&str, &str> {
tag(", ")(input)
}
在这里，我为构建块创建了一组基本的解析器，例如"；数字"分离器""定界符"；，各种标记(分钟、秒等(。这些都不希望是"；全词"；。相反，您应该使用组合子，如terminated、tuple、all_consuming来标记"；确切的单词"；结束。