Enum Either 

pub enum Either<L, R> {
    Left(L),
    Right(R),
}

Accept one of two extractors, whichever succeeds.

The usual case is an endpoint that takes either JSON or a form:

use churust_core::{Churust, Either, Form, TestClient};
use serde::Deserialize;
#[derive(Deserialize)]
struct Note { text: String }

let app = Churust::server()
    .routing(|r| {
        r.post("/notes", |body: Either<Form<Note>, String>| async move {
            match body {
                Either::Left(Form(n)) => format!("form: {}", n.text),
                Either::Right(raw) => format!("raw: {raw}"),
            }
        });
    })
    .build();

let res = TestClient::new(app)
    .post("/notes")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("text=hi")
    .send()
    .await;
assert_eq!(res.text(), "form: hi");

Left is tried first. If it fails, the call is handed to Right — which is why the call is cloned rather than moved: a failed first attempt must not have consumed the body. When both fail, the second error is reported, since the right-hand side is the fallback and its complaint is usually the more informative one.

Variants

Left(L)

The first extractor succeeded.

Right(R)

The first failed and the second succeeded.

Trait Implementations

impl<L, R> FromCall for Either<L, R>

where L: FromCall, R: FromCall,

fn from_call<'async_trait>( call: Call, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where Self: 'async_trait,

Build Self by consuming the call, or return an Error (which the handler renders as the response).