FromRequest

tosic_http::traits::from_request

Trait FromRequest

pub trait FromRequest: Sized {
    type Error: Into<Error>;
    type Future: Future<Output = Result<Self, Self::Error>>;

    // Required method
    fn from_request(
        req: &HttpRequest,
        payload: &mut HttpPayload,
    ) -> Self::Future;

    // Provided method
    fn extract(req: &HttpRequest) -> Self::Future { ... }
}

Expand description

§FromRequest

The FromRequest trait is used to define how to extract data from the request

Any type that implements FromRequest can be used as an extractor and will be extracted from the request automatically in a handler

Required Associated Types§

type Error: Into<Error>

The error that can happen when extracting data

type Future: Future<Output = Result<Self, Self::Error>>

The future that will be used to extract the data

Required Methods§

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

Extracts a value of type Self from the request. The request contains the request body at the moment but that might change in the future

Provided Methods§

fn extract(req: &HttpRequest) -> Self::Future

Extracts a value of type Self from the request

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

impl FromRequest for ()

type Error = Infallible

type Future = Ready<Result<(), <() as FromRequest>::Error>>

fn from_request(_: &HttpRequest, _: &mut HttpPayload) -> Self::Future

impl FromRequest for Bytes

type Error = Infallible

type Future = Ready<Result<Bytes, <Bytes as FromRequest>::Error>>

fn from_request(_: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static> FromRequest for (A,)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture1<A>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static> FromRequest for (A, B)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture2<A, B>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static> FromRequest for (A, B, C)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture3<A, B, C>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static> FromRequest for (A, B, C, D)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture4<A, B, C, D>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static> FromRequest for (A, B, C, D, E)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture5<A, B, C, D, E>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static> FromRequest for (A, B, C, D, E, F)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture6<A, B, C, D, E, F>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture7<A, B, C, D, E, F, G>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture8<A, B, C, D, E, F, G, H>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture9<A, B, C, D, E, F, G, H, I>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture10<A, B, C, D, E, F, G, H, I, J>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture11<A, B, C, D, E, F, G, H, I, J, K>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture12<A, B, C, D, E, F, G, H, I, J, K, L>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture13<A, B, C, D, E, F, G, H, I, J, K, L, M>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static, T: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static, T: FromRequest + 'static, U: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture21<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static, T: FromRequest + 'static, U: FromRequest + 'static, V: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture22<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static, T: FromRequest + 'static, U: FromRequest + 'static, V: FromRequest + 'static, W: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture23<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static, T: FromRequest + 'static, U: FromRequest + 'static, V: FromRequest + 'static, W: FromRequest + 'static, X: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static, T: FromRequest + 'static, U: FromRequest + 'static, V: FromRequest + 'static, W: FromRequest + 'static, X: FromRequest + 'static, Y: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture25<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<A: FromRequest + 'static, B: FromRequest + 'static, C: FromRequest + 'static, D: FromRequest + 'static, E: FromRequest + 'static, F: FromRequest + 'static, G: FromRequest + 'static, H: FromRequest + 'static, I: FromRequest + 'static, J: FromRequest + 'static, K: FromRequest + 'static, L: FromRequest + 'static, M: FromRequest + 'static, N: FromRequest + 'static, O: FromRequest + 'static, P: FromRequest + 'static, Q: FromRequest + 'static, R: FromRequest + 'static, S: FromRequest + 'static, T: FromRequest + 'static, U: FromRequest + 'static, V: FromRequest + 'static, W: FromRequest + 'static, X: FromRequest + 'static, Y: FromRequest + 'static, Z: FromRequest + 'static> FromRequest for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

FromRequest implementation for tuple

type Error = Error

type Future = TupleFromRequestFuture26<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<E> FromRequest for Option<E>
where E: FromRequest + Send, E::Future: Send + 'static,

type Error = Infallible

type Future = impl Future<Output = Result<Option<E>, <Option<E> as FromRequest>::Error>> + Send

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

impl<E, Err> FromRequest for Result<E, Err>
where E: FromRequest + Send, E::Future: Send + 'static, Err: ResponseError + From<E::Error> + Send,

type Error = Infallible

type Future = impl Future<Output = Result<Result<E, Err>, <Result<E, Err> as FromRequest>::Error>> + Send

fn from_request(req: &HttpRequest, payload: &mut HttpPayload) -> Self::Future

Implementors§

impl FromRequest for HttpRequest

type Error = Infallible

type Future = Ready<Result<HttpRequest, <HttpRequest as FromRequest>::Error>>

impl<A: FromStr> FromRequest for Path<(A,)>
where A::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A,)>, <Path<(A,)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr> FromRequest for Path<(A, A1)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1)>, <Path<(A, A1)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr> FromRequest for Path<(A, A1, A2)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2)>, <Path<(A, A1, A2)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr> FromRequest for Path<(A, A1, A2, A3)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3)>, <Path<(A, A1, A2, A3)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr> FromRequest for Path<(A, A1, A2, A3, A4)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4)>, <Path<(A, A1, A2, A3, A4)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5)>, <Path<(A, A1, A2, A3, A4, A5)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6)>, <Path<(A, A1, A2, A3, A4, A5, A6)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr, A20: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug, A20::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr, A20: FromStr, A21: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug, A20::Err: ResponseError + Display + Debug, A21::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr, A20: FromStr, A21: FromStr, A22: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug, A20::Err: ResponseError + Display + Debug, A21::Err: ResponseError + Display + Debug, A22::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr, A20: FromStr, A21: FromStr, A22: FromStr, A23: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug, A20::Err: ResponseError + Display + Debug, A21::Err: ResponseError + Display + Debug, A22::Err: ResponseError + Display + Debug, A23::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr, A20: FromStr, A21: FromStr, A22: FromStr, A23: FromStr, A24: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug, A20::Err: ResponseError + Display + Debug, A21::Err: ResponseError + Display + Debug, A22::Err: ResponseError + Display + Debug, A23::Err: ResponseError + Display + Debug, A24::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr, A20: FromStr, A21: FromStr, A22: FromStr, A23: FromStr, A24: FromStr, A25: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug, A20::Err: ResponseError + Display + Debug, A21::Err: ResponseError + Display + Debug, A22::Err: ResponseError + Display + Debug, A23::Err: ResponseError + Display + Debug, A24::Err: ResponseError + Display + Debug, A25::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)> as FromRequest>::Error>>

impl<A: FromStr, A1: FromStr, A2: FromStr, A3: FromStr, A4: FromStr, A5: FromStr, A6: FromStr, A7: FromStr, A8: FromStr, A9: FromStr, A10: FromStr, A11: FromStr, A12: FromStr, A13: FromStr, A14: FromStr, A15: FromStr, A16: FromStr, A17: FromStr, A18: FromStr, A19: FromStr, A20: FromStr, A21: FromStr, A22: FromStr, A23: FromStr, A24: FromStr, A25: FromStr, A26: FromStr> FromRequest for Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)>
where A::Err: ResponseError + Display + Debug, A1::Err: ResponseError + Display + Debug, A2::Err: ResponseError + Display + Debug, A3::Err: ResponseError + Display + Debug, A4::Err: ResponseError + Display + Debug, A5::Err: ResponseError + Display + Debug, A6::Err: ResponseError + Display + Debug, A7::Err: ResponseError + Display + Debug, A8::Err: ResponseError + Display + Debug, A9::Err: ResponseError + Display + Debug, A10::Err: ResponseError + Display + Debug, A11::Err: ResponseError + Display + Debug, A12::Err: ResponseError + Display + Debug, A13::Err: ResponseError + Display + Debug, A14::Err: ResponseError + Display + Debug, A15::Err: ResponseError + Display + Debug, A16::Err: ResponseError + Display + Debug, A17::Err: ResponseError + Display + Debug, A18::Err: ResponseError + Display + Debug, A19::Err: ResponseError + Display + Debug, A20::Err: ResponseError + Display + Debug, A21::Err: ResponseError + Display + Debug, A22::Err: ResponseError + Display + Debug, A23::Err: ResponseError + Display + Debug, A24::Err: ResponseError + Display + Debug, A25::Err: ResponseError + Display + Debug, A26::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)>, <Path<(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)> as FromRequest>::Error>>

impl<T: Send + Sync + 'static> FromRequest for Data<T>

type Error = ExtractionError

type Future = Ready<Result<Data<T>, <Data<T> as FromRequest>::Error>>

impl<V: FromStr> FromRequest for Path<Vec<V>>
where V::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<Vec<V>>, <Path<Vec<V>> as FromRequest>::Error>>

impl<V: FromStr, const N: usize> FromRequest for Path<[V; N]>
where V::Err: ResponseError + Display + Debug,

type Error = ExtractionError

type Future = Ready<Result<Path<[V; N]>, <Path<[V; N]> as FromRequest>::Error>>

impl<V: DeserializeOwned> FromRequest for Json<V>

type Error = ServerError

type Future = Ready<Result<Json<V>, <Json<V> as FromRequest>::Error>>

impl<V: DeserializeOwned> FromRequest for Query<V>

type Error = ExtractionError

type Future = Ready<Result<Query<V>, <Query<V> as FromRequest>::Error>>