It is suggested to improve usability of dev::ServiceRequest.

[myyrakle]

When writing middleware, it is common to disassemble and use ServiceRequest objects.
However, there is a problem when recreating the ServiceRequest object with the disassembled HttpRequest and Payload.


To unwrap, Result's Error type must implement Debug trait, but it cannot.
This is because (HttpRequest, Payload) is returned as the error type.

The best way to solve this now is to use unwrap by converting Result to Option.

However, it is not intuitive and inconvenient.
How about changing the type by defining a dedicated error type, or changing the result to an option altogether?

[fakeshadow]

It returns the ownership back to you so you don't lose them forever.

In general don't use unwrap for error handling. You want to handle the error properly.

[fakeshadow]

In fact this is what unwrap_or is

    pub fn unwrap_or(self, default: T) -> T {
        match self {
            Ok(t) => t,
            Err(_) => default,
        }
    }

[myyrakle]

Even with error handling as per your advice, I will need to unwrap to get the value eventually.
What am I doing wrong?

[fakeshadow]

You are not handling error. You literly just try to unwrap it again.
Handling error means return an error according to the Service::Error type or construct a ServiceResponse which would represent the error you want to return to client.

[fakeshadow]

    fn handle_error(req: HttpRequest) -> Result<ServiceResponse, actix_web::Error> {
        match ServiceRequest::from_parts(req, Payload::None) {
            Ok(req) => {
                Ok(req.into_response("OK"))
            },
            Err((req, _)) => {
                Ok(ServiceResponse::from_err(actix_web::error::ErrorInternalServerError("Error"), req))
            }
        }
    }

[myyrakle]

Oh... thank you. I was thinking wrong.