Generic associated type constraint question

generic_assoc_type_constraint.rs

// In crate `endpoint`:

pub trait Endpoint {
    type Request: TryInto<hyper::Request>;
    type Response: TryFrom<hyper::Response>;
}

// In crate `client`:

pub struct Client;
pub struct Error;

// I want to express:
//
// "Implement `Service` for `Client` for any `Endpoint`, mapping the endpoint's request and
// response to the service's request and response."
//
// The goal is to be able to do:
//
// ```
// let foo_request = foo::Request::new();
// client.call(foo_request).and_then(|_| ...);
//
// let bar_request = bar::Request::new();
// client.call(bar_request).and_then(|_| ...);
// ```
//
// where `foo::Request` and `bar::Request` are `Endpoint::Request` for some type implementing
// `Endpoint`.
//
// What is the proper syntax for this? Is it even possible currently?
// The below currently results in this error, as expected:
//
//    the type parameter `E` is not constrained by the impl trait, self type, or predicates
impl<E> tokio_service::Service for Client where E: endpoint::Endpoint {
    type Request = E::Request;
    type Response = E::Response;
    type Error = Error;
    type Future = Box<futures::Future<Item = Self::Request, Error = Self::Error>>;

    fn call(&self, req: Self::Request) -> Self::Future {
        // ...
    }
}