How to parse between (too) many alternatives?

[DavidAntliff]

I'm writing a lexer and I'm not at the point where I want or need to optimise it, so I'm using a large alt parser to select between one of many sub-parsers. This pattern is working well, even if it's not very efficient for now.

However, I've run out of parameters in the internal alt implementation (21 seems to be the limit). The docs don't seem to say what to do if you want to exceed this.

What's the best way to split this up? Is there a trick to extending alt to support more alternatives?

I am wondering if I can use blocks of alt inside alt for now, and maybe switch to dispatch!(peek... a bit later when I get around to optimising.

Is dispatch!() limited in the number of alternatives it can handle? Will I have the same problem with that?

[epage]

Yes, nesting alt()s within alt()s should work. The limitation is similar to (sequenced, parsers). This comes from us having to explicitly enumerate a trait implementation for every tuple length we want to support.

dispatch! does not have this problem as its a macro that is directly generating the code and it generates a match statement which can be as large as you want.