Function kparse::combinators::track

pub fn track<PA, C, I, O, E>(
    func: C,
    parser: PA
) -> impl FnMut(I) -> Result<(I, O), Err<E>>where
    PA: Parser<I, O, E>,
    C: Code,
    I: Clone + Debug + TrackedSpan<C> + InputTake + InputLength + InputIter + AsBytes,
    Err<E>: KParseError<C, I>,

Tracked execution of a parser.

use nom::bytes::complete::tag;
use nom::Parser;
use kparse::combinators::{err_into, with_code, track, map_res};
use kparse::examples::{ExParserResult, ExSpan, ExTagB, ExTokenizerResult};
use kparse::KParseError;

fn parse_b(input: ExSpan<'_>) -> ExParserResult<'_, AstB> {
    err_into(track(ExTagB,
        map_res(nom_parse_b, |span| Ok(AstB { span }))
    ))(input)
}

fn nom_parse_b(i: ExSpan<'_>) -> ExTokenizerResult<'_, ExSpan<'_>> {
    with_code(tag("b"), ExTagB).parse(i)
}

struct AstB<'s> {
    pub span: ExSpan<'s>,
}

The same can be achieved in a imperative style.

use nom::bytes::complete::tag;
use nom::Parser;
use kparse::{Track, KParser};
use kparse::examples::{ExParserResult, ExSpan, ExTagA, ExTokenizerResult};
use kparse::prelude::*;

fn parse_a(input: ExSpan<'_>) -> ExParserResult<'_, AstA> {
    Track.enter(ExTagA, input);
    let (rest, tok) = nom_parse_a.err_into().parse(input).track()?;
    Track.ok(rest, tok, AstA { span: tok })
}

fn nom_parse_a(i: ExSpan<'_>) -> ExTokenizerResult<'_, ExSpan<'_>> {
    tag("a").with_code(ExTagA).parse(i)
}

#[derive(Debug)]
struct AstA<'s> {
    pub span: ExSpan<'s>,
}