Converting a small parser from 0.9 to 1alpha - missing chain method

[dovreshef]

Hi

I have the following parser:

 let byte = filter(char::is_ascii_hexdigit)
        .repeated()
        .exactly(2)
        .collect::<String>()
        .map(|v| u8::from_str_radix(&v, 16).unwrap());

    let hex = byte
        .chain(
            just::<_, _, Simple<_>>(':')
                .ignore_then(byte.separated_by(just(':')))
                .or(byte.repeated()),
        )
        .then_ignore(end());

This hex parser parse either a byte string formatted either as "1a:2b:3c:4e" or "1a2b3c4e".

I'm trying to move to the 1alpha version, and I see that the chain method on parser was removed.
What's the recommended alternative to replace it?

[zesterer]

You should use map_slice or slice instead, giving you access to the underlying input slice that was parsed by the parser, without any allocations at all.

[zesterer]

This seems like it would do what you want:

let byte = any().filter(char::is_ascii_hexdigit)
        .repeated()
        .exactly(2)
        .map_slice(|s| u8::from_str_radix(s, 16).unwrap());

let hex = byte
	.repeated()
        .at_least(1)
	.collect::<Vec<_>>()
	.or(byte
		.separated_by(just(':'))
		.at_least(1)
		.collect());

FYI, .then_ignore(end()) is no longer necessary in chumsky 1.0 :)

[Zij-IT]

I believe that would have to be at_least(2) for the first part of hex, because it will otherwise parse "ab:cd" incorrectly.

Assuming however that you do get it to produce the same output, it will still have a small difference from the original; It doesn't matter for this parser, but could when byte is more complex.

Given the input "ab:cd" the first byte "ab" is parsed twice in your solution, but only parsed once in the original. If we assume for a moment that byte is arbitrarily complex (like a language expression), then re-parsing it could be costly.

[dovreshef]

It also does not work, sadly..

A self containing, failing example:

use chumsky::prelude::*;

fn hex_parser<'src>() -> impl Parser<'src, &'src str, Vec<u8>, extra::Err<Rich<'src, char>>> {
    let byte = any()
        .filter(char::is_ascii_hexdigit)
        .repeated()
        .exactly(2)
        .map_slice(|v: &str| u8::from_str_radix(v, 16).unwrap());

    byte.repeated()
        .at_least(1)
        .collect::<Vec<_>>()
        .or(byte.separated_by(just(':')).at_least(1).collect())
}

fn main() {
    let v = hex_parser().parse("01020304").unwrap();
    assert_eq!(v, vec![0x01, 0x02, 0x03, 0x04]);
    let v = hex_parser().parse("01:02:03:04").unwrap();
    assert_eq!(v, vec![0x01, 0x02, 0x03, 0x04]);
}

The second assert fails, after it parses the first byte. It does not go to the or case since it has already succeed once with the first parser..

[zesterer]

Right, in that case you can just put the separated case first:

let byte = any().filter(char::is_ascii_hexdigit)
    .repeated()
    .exactly(2)
    .map_slice(|s| u8::from_str_radix(s, 16).unwrap());

let hex = byte
    .separated_by(just(':'))
    .at_least(2)
    .collect::<Vec<_>>()
    .or(byte
        .repeated()
        .at_least(1)
        .collect());

[dovreshef]

Thanks! that solved this.

And thanks for the library, it is very useful!