Rust typechecker getting in the way

[ararunaufc]

I'm new to chumsky (but not that new to Rust) and I just started implementing a parser for the CSS Syntax Module Level 3 and their concept of "new line" is very simple buy yet different from what the provided text::newline does in chumsky.

I'm using v1.0.0-alpha.4. I tried implementing it like this:

just(b"\r\n").or(just(b'\n')).or(just(b'\r')).or(just(b'\x0C'))

And (this time understandably), it complains saying I'm "mixing u8s and &[u8]s". But then, when I try this:

just(b"\r\n").or(just(b"\n")).or(just(b"\r")).or(just(b"\x0C"))

Rust treats all of the parameters as arrays and not slices, and complains they have different lengths...! I also tried the shorter:

just(b"\r\n").or(one_of(b"\n\r\x0C"))

And also no luck... What can I add to make it infer the right type? Also, is there a way to change implementation to prevent this from happening?

Thank you, guys.

---

Edits: just to add context and make things prettier.

[ararunaufc]

I believe I found the answer. It suffices to call .as_ref() (at least in this case).

But I still wanted to call out for an easier "situation"...

I thought I had found it, but it doesn't work... (some other error got in the way and rustic didn't emit the previous error)

The error I get is this:

error[E0271]: type mismatch resolving `<&[u8] as Input<'_>>::Token == &[u8]`
    --> src/syntax/tokenize.rs:23:31
     |
23   |     just(b"\r\n".as_ref()).or(one_of(b"\r\n\x0C".as_ref())).ignored()
     |                            -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&[u8]`, found `u8`
     |                            |
     |                            required by a bound introduced by this call
     |
     = note: required for `OneOf<&[u8], &[u8], chumsky::extra::Full<EmptyErr, (), ()>>` to implement `chumsky::Parser<'_, &[u8], &[u8]>`
note: required by a bound in `or`
    --> /home/araruna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-1.0.0-alpha.4/src/lib.rs:1190:12
     |
1187 |     fn or<B>(self, other: B) -> Or<Self, B>
     |        -- required by a bound in this associated function
...
1190 |         B: Parser<'a, I, O, E>,
     |            ^^^^^^^^^^^^^^^^^^^ required by this bound in `Parser::or`

This is the whole function:

pub fn newline<'i>() -> impl Parser<'i, &'i [u8], ()> {
    just(b"\r\n".as_ref()).or(one_of(b"\r\n\x0C".as_ref())).ignored()
}

[zesterer]

So, you have two options here:

1. Change all of the justs to accept strings, like so:

just(b"\r\n").or(just(b"\n")).or(just(b"\r")).or(just(b"\x0C"))

Because b"..." produces an array, this will compile down to exactly the same thing as if you'd just used single characters ([u8; 1] vs u8).

2. change the output type of a parsing using .map(...), .ignored(), .to(...), etc.

just(b"\r\n").ignored()
    .or(just(b'\n').ignored())
    .or(just(b'\r').ignored())
    .or(just(b'\x0C').ignored())

or

just(b"\r\n")
    .or(just(b'\n').to(b""))
    .or(just(b'\r').to(b""))
    .or(just(b'\x0C').to(b""))

I'd personally go for option (1) simply because it's shorter, but it's obviously your call. All options will probably compile down to near enough the same code anyway.

Side note: I personally find choice a visually nicer thing to use for long or chains like this (the behaviour is the same):

choice((
    just(b"\r\n"),
    just(b"\n"),
    just(b"\r"),
    just(b"\x0C"),
))

[ararunaufc]

Side note: I personally find choice a visually nicer thing to use for long or chains like this (the behaviour is the same):

choice with as_ref worked!

choice((
    just(b"\r\n".as_ref()),
    just(b"\n".as_ref()),
    just(b"\r".as_ref()),
    just(b"\x0C".as_ref()),
))

Thanks.