Generics Error: expected type parameter, found struct

Question

I started a new project, where I want to be as modular as possible, by that I mean that I would like to be able to replace some parts with others in the future. This seems t

Answer 1

First error: you create a Rustmark object with the field parser of type DefaultParser and the field renderer of type HTMLRenderer, but the function is expected to return Rustmark <P, R>. In general P is not of type DefaultParser and R is not of type HTMLRenderer, so it will never compile. A good solution if you want have default values of the right type is to bound P and R to implement the Default trait, this way:

use std::default:Default;

impl <P: MarkParser + Default, R: MarkRenderer + Default> Rustmark <P, R> {
    fn new() -> Rustmark <P, R> {
        Rustmark {
            parser: P::default(),
            renderer: R:default(),
        }
    }
}

Second error: that main problem is that you return a reference of something that probably will die inside the rendermethod (the String you allocate in the inner rendermethod probably). The compiler is telling you that it doesn't know the lifetime of the object that is pointed by that reference, so it cannot guarantee that the reference is valid. You can specify a lifetime parameter but in your case probably the best solution is to return the String object itself, not a reference.

Answer 2

Following the answer of Andrea P I looked up the default trait in std. Which is defined like this:

pub trait Default {
    fn default() -> Self;
}

And what I ended up doing was not use the default trait but add a constructor new in my MarkParser and MarkRenderer traits like this:

pub trait MarkParser {
    fn new() -> Self;
    fn parse(&self, input: &str) -> &str;
}

The key piece that I didn't know about was the Self keyword and in this way I can write my implementation like this:

impl <P: MarkParser, R: MarkRenderer> Rustmark <P, R> {
    fn new() -> Rustmark <P, R> {
        Rustmark {
            parser: P::new(),
            renderer: R::new(),
        }
    }

    fn render(&self, input: &str) -> &str {
        self.renderer.render(self.parser.parse(input))
    }
}

This is exactly the same thing as implementing the Default trait, except that I get to use new instead of default which I prefer and I don't have to add the Default trait to the impl of RustMark.

impl <P: MarkParser, R: MarkRenderer> Rustmark <P, R> {

instead of

impl <P: MarkParser + Default, R: MarkRenderer + Default> Rustmark <P, R> {

Big thanks to Andrea P for pointing me in the right direction.