Cannot implement trait for generic struct where types are also generic

[fuchsnj]

In this example code, I want to implement the trait Convert for the struct Combine (which combines 2 Converts)
(code in playground)

pub trait Convert<D1, D2>{
    fn convert(&self, data: D1) -> D2;
}
impl<D1, D2, T> Convert<D1, D2> for T
where T: Fn(D1) -> D2{
    fn convert(&self, data:D1) -> D2{
        (*self)(data)
    }
}

//combines 2 Converts into 1
pub struct Combine<C1, C2>{
    a: C1,
    b: C2
}

impl<C1, C2, D1, D2, D3> Convert<D1, D3> for Combine<C1, C2> where
C1: Convert<D1, D2>,
C2: Convert<D2, D3>{
    fn convert(&self, data: D1) -> D3{
        let value: D2 = self.a.convert(data);
        self.b.convert(value)
    }
}

fn main(){
    let converter = Combine{
        a: |d|{"".to_string()},
        b: |d|{true}
    };
    let value:bool = converter.convert(4);
    println!("value: {:?}", value);
}

but this gets

<anon>:17:18: 17:20 error: the type parameter `D2` is not constrained by the impl trait, self type, or predicates [E0207]
<anon>:17 impl<C1, C2, D1, D2, D3> Convert<D1, D3> for Combine<C1, C2> where
                           ^~
<anon>:17:18: 17:20 help: see the detailed explanation for E0207
error: aborting due to previous error

I have seen a few ugly solutions, such as putting D2 into the struct as PhantomData but this doesn't work if for example the Combine struct were required to be Send + Sync and D2 could not be Send + Sync.

[Stebalien]

The problem is that, if D2 isn't fixed (as in your example), there could be multiple paths from D1 -> D2 -> D3 given multiple Convert implementations on C1 and C2. Unfortunately, D2 can't be specifid when calling Convert::<D1, D3>::convert because the trait only knows about the endpoints, not the intermediate. Therefore, you have to specify D2 in the struct (Combine) itself. One way to do this is to use a PhantomData<fn(D1) -> D2> to assert that C1 goes from D1 -> D2. This will be Send + Sync + Copy.

Alternatively, if you don't want to be able to parametrize Convert on the output type, you can use an associated type and the unboxed_closures unstable feature:

#![feature(unboxed_closures)]

pub trait Convert<Input> {
    type Output;

    fn convert(&self, data: Input) -> Self::Output;
}

impl<Input, T> Convert<Input> for T
    where T: Fn<(Input,)>
{
    type Output = T::Output;
    fn convert(&self, data: Input) -> Self::Output {
        (*self)(data)
    }
}

//combines 2 Converts into 1
pub struct Combine<C1, C2>
{
    a: C1,
    b: C2
}

impl<C1, C2, Input> Convert<Input> for Combine<C1, C2>
    where C1: Convert<Input>,
          C2: Convert<C1::Output>
{
    type Output = C2::Output;

    fn convert(&self, data: Input) -> Self::Output {
        let value = self.a.convert(data);
        self.b.convert(value)
    }
}

fn main(){
    let converter = Combine{
        a: |d|{"".to_string()},
        b: |d|{true}
    };
    let value:bool = converter.convert(4);
    println!("value: {:?}", value);
}

[fuchsnj]

Thanks, I think that clears up the issue for me. Looks like this isn't really a problem after all. Closing.