How can I make a static array with references to trait implementations in Rust?

Question

I want to be able to iterate over an array of parsers trying to find a delegate parser from a main parsing function. The list of parsers is known at compile-time, so I want this to be a constant.

I've tried some varieties of this but I can't get it to work:

const ALL_PARSERS: [&Parser; 1] = [&CommentParser {}];

How can I achieve this?

Notes:

• Parser is a trait.
• CommentParser is a struct implementing Parser.
• there are other implementations of Parser but they are not shown for simplicity.
• even though all parser implementations are known at compile-time, I just want to avoid explicitly trying one by one as that would make the code worse than I think it should be.

The error I get currently:

|
11 | const ALL_PARSERS: [&Parser; 1] = [&CommentParser {}];
   |                    ^^^^^^^^^^^^ the trait `parsers::Parser` cannot be made into an object
   |
   = note: method `parse` has generic type parameters

I can't see any generics in the parse method:

pub trait Parser {
    fn opening_char(self: &Self) -> char;
    fn parse(&mut self, env: impl ParserEnv) -> ParseResult;
}

If I make the types values:

const ALL_PARSERS: [Parser; 1] = [CommentParser {}];

The error becomes:

11 | const ALL_PARSERS: [Parser; 1] = [CommentParser {}];
|                    ^^^^^^^^^^^ doesn't have a size known at compile-time
|
= help: the trait `std::marker::Sized` is not implemented for `(dyn parsers::Parser + 'static)`

Answer 1

Trait references need to be marked as &dyn, e.g. &dyn Parser:

trait Parser { }

struct CommentParser { }
impl Parser for CommentParser { }

const ALL_PARSERS: [&dyn Parser; 1] = [&CommentParser {}];

fn main() {
    for &parser in &ALL_PARSERS {
        // do something with parser
    }
}

Link to playground example

---

Also, as this answer to a related question states, you can't have a generic parameter in your trait if you want to make a trait reference, so you'll need to either add a generic type to the trait itself, or use a trait reference instead of impl in your parser type:

// original (with error)
trait Parser {
    // impl ParserEnv is an implicit generic type
    fn parse(&mut self, env: impl ParserEnv) -> ParseResult;

    // same as:
    //   fn parser<E: ParserEnv>(&mut self, env: E) -> ParserResult;
}

// alternative 1, with trait generic type
trait Parser<E: ParserEnv> {
    fn parse(&mut self, env: E) -> ParseResult;
}

// alternative 2, with trait reference
trait Parser {
    fn parser(&mut self, env: &dyn ParserEnv) -> ParserResult;
    // may need &dyn mut ParserEnv if you want to modify env as well
}

I think the second approach may be the best, since then you can store the parsers in the array without needing to assign a particular ParserEnv type to the parsers.