Parsing union types

[numToStr]

Hi,

I am trying to parse union and "primitive" types but couldn't find a way to differentiate both types during parsing.

• Union

number|string|boolean

• Primitive

string

I tried the following using separated_by() but I am always getting Ty::Union variant even If | is not present i.e., primitive type.

#[derive(Debug, Clone)]
enum Primary {
    String,
    Number,
    Boolean,
}

#[derive(Debug, Clone)]
enum Ty {
    Union(Vec<Primary>),
    Primary(Primary),
}

let typ = choice((
    just("string").to(Primary::String),
    just("number").to(Primary::Number),
    just("boolean").to(Primary::Boolean),
));

choice((
    typ.separated_by(just('|').padded()).map(Ty::Union),
    typ.map(Ty::Primary),
));

I can't figure out how to fix this(?). I also tried something different but got same results. I would appreciate If you could help me with this :)

Thanks.

[bew]

Hello! I think you can fix it by calling at_least(2) on the SeperatedBy structure:
Ref: https://docs.rs/chumsky/0.8.0/chumsky/combinator/struct.SeparatedBy.html#method.at_least

[numToStr]

There could be multiple union members, so at_least(n) won't work. And I believe separated_by doesn't rewind if the next token is not as same as what is provided. Sorry! I was wrong, at_least(2) does work.

[numToStr]

Edit: #206 (comment) This is also correct.

---

After doing some more brute force, I found a solution and the solution was jokingly obvious.

choice((
    typ.then_ignore(just('|')).chain(typ.separated_by(just('|'))).map(Ty::Union),
    typ.map(Ty::Primary),
));

Now the parser is checking for the next token |, if it's there then it'll recursively parse other union members using separated_by and chaining the result in a Vec, else it'll fallback to Ty::Primary. I hope I understood it correctly :)

[zesterer]

A simple alternative might be to just do this:

typ.separated_by(just('|')).at_least(1).map(|tys| if tys.len() == 1 {
    Ty::Primary(tys.remove(0))
} else {
    Ty::Union(tys)
})