How can I constrain generic type arguments of a trait which depend on each other?

Question

I have a trait for types which process data:

pub trait Stage<I, O>: Sized {}

Here, I and O represent the input and output data types respectively. I want to create an implementation of Stage which combines two other Stages:

pub struct CompoundStage<S0: Stage<_, _>, S1: Stage<_, _>>(S0, S1);

CompoundStage must itself be a Stage:

impl<S0: Stage<_, _>, S1: Stage<_, _>> Stage<S0::I, S1::O> for CompoundStage<S0, S1> {}

How can I constrain the type arguments of CompoundStage such that the “intermediate” type is consistent (i.e. S0::O == S1::I)? I know I could do it by adding another type parameter like below, but is there a cleaner way?

pub struct CompoundStage<S0: Stage<_, T>, S1: Stage<T, _>, T>(S0, S1);

impl<S0: Stage<_, T>, S1: Stage<T, _>, T> Stage<S0::I, S1::O> for CompoundStage<S0, S1, T> {}

Answer 1

You probably want a trait with associated types instead of generic types:

pub trait Stage: Sized {
    type I;
    type O;
}

pub struct CompoundStage<S0, S1>(S0, S1);

impl<S0, S1> Stage for CompoundStage<S0, S1>
where
    S0: Stage,
    S1: Stage<I = S0::O>,
{
    type I = S0::I;
    type O = S1::O;
}

See also:

• When is it appropriate to use an associated type versus a generic type?
• Should trait bounds be duplicated in struct and impl?
• How can I enforce equality of two associated type parameters of traits?
• Matching a generic parameter to an associated type in an impl
• Constraints on associated trait types

---

If you must use generic types, you will need to introduce PhantomData:

use std::marker::PhantomData;

pub trait Stage<I, O>: Sized {}

pub struct CompoundStage<S0, S1, M>(S0, S1, PhantomData<M>);

impl<S0, S1, I, O, M> Stage<I, O> for CompoundStage<S0, S1, M>
where
    S0: Stage<I, M>,
    S1: Stage<M, O>,
{
}