How to make the return value Result<Response<dyn Body>>,...>

[pymumu]

I want to implement a routing mechanism. The current code is as follows and it works well.

type APIRouteFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
type APIRouterFun = fn(
    req: Request<body::Incoming>,
) -> APIRouteFuture<'static, Result<Response<Full<Bytes>>, HttpError>>;

pub struct APIRouter {
    pub method: Method,
    pub auth: bool,
    pub handler: APIRouterFun,
}

pub struct API {
    router: Router<std::collections::HashMap<Method, APIRouter>>,
}

But I encountered a problem:
The hyper interface requires the return value type to be Result<Response<Full>, ..> or Result<Response<BoxedBody>, ..> or other
It seems that the return value cannot be defined as Result<Response,...>. If I want to return StreamBody, I need to modify the return value type, but then I cannot use the router mechanism.

Please tell me what the solution is.

Function you want to achieve:

1. Routing by path.
2. Some functions return text.
3. Some functions return chunked data. These chunked data come from tokio::sync::mpsc::channel and will not end unless the client terminates. (I don’t know how to implement it yet)

[seanmonstar]

What you're experiencing is a property of Rust: you need to be explicit about your return type. When you need to be able to return multiple different types, there's two main ways to that in Rust: using an enum, or a boxed trait object. The http-body-util crate provides a couple of types to help you do that.

• Either is an enum, where you can set it to be something like Either<Full<B>, StreamBody<S>>. You can also nest multiple Either enums, if need be.
• BoxBody eases making a Box<dyn Body>, which can hold any type, while requiring an allocation and possibly less inlining. It is easier to use with more than two types than the enum option.

It's up to you to decide which fits your needs better.

[pymumu]

BoxBody

I tried to write it as follows, but an error was reported. The Body needs to specify the specific types of Data and Error.

async fn server_handle_http_request(
    req: Request<body::Incoming>,
 ) -> Response<BoxBody<Box<dyn Body>, hyper::Error>> {
}

specify the associated types: `Body<Data = Type, Error = Type>`rustc[E0191](https://doc.rust-lang.org/error-index.html#E0191)
the value of the associated types `Error` and `Data` in `Body` must be specifiedrustc
http_server.rs(529, 35): specify the associated types: `Body<Data = Type, Error = Type>`

There is no problem after setting the data type, but writing this way brings me back to the starting point.

async fn server_handle_http_request(
     req: Request<body::Incoming>,
) -> Response<BoxBody<Box<dyn Body<Data = bytes::Bytes, Error = hyper::Error>>, hyper::Error>> {
}

Either

I tried Either too.

 async fn server_handle_http_request(
      req: Request<body::Incoming>,
  ) -> Result<Response<Either<Full<Bytes>, StreamBody<Bytes>>> , Infallible> {
  }

An error was reported by serve_connection

let conn = http1::Builder::new()
                .serve_connection(io, service_fn(handle_func))
                .with_upgrades()
                .await;

Error:

the method `with_upgrades` exists for struct `Connection<TokioIo<TcpStream>, ServiceFn<{closure@http_server.rs:662:27}, Incoming>>`, but its trait bounds were not satisfied
consider using `--verbose` to print the full type name to the console
the following trait bounds were not satisfied:
`bytes::Bytes: futures::Stream`
which is required by `http_body_util::Either<http_body_util::Full<bytes::Bytes>, StreamBody<bytes::Bytes>>: Body`
`bytes::Bytes: futures::Stream`
which is required by `<http_body_util::Either<http_body_util::Full<bytes::Bytes>, StreamBody<bytes::Bytes>> as Body>::Error = Box<(dyn StdError + std::marker::Send + Sync + 'static)>`
http_server.rs(665, 24):
either.rs(16, 1): doesn't satisfy `<_ as Body>::Error = Box<dyn Error + Send + Sync>` or `_: Body`
bytes.rs(101, 1): doesn't satisfy `bytes::Bytes: futures::Stream`

The hyper version is 1.4.1