Enum actix_web::web::Either

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

Combines two extractor or responder types into a single type.

Extractor

Provides a mechanism for trying two extractors, a primary and a fallback. Useful for “polymorphic payloads” where, for example, a form might be JSON or URL encoded.

It is important to note that this extractor, by necessity, buffers the entire request payload as part of its implementation. Though, it does respect any PayloadConfig maximum size limits.

use actix_web::{post, web, Either};
use serde::Deserialize;

#[derive(Deserialize)]
struct Info {
    name: String,
}

// handler that accepts form as JSON or form-urlencoded.
#[post("/")]
async fn index(form: Either<web::Json<Info>, web::Form<Info>>) -> String {
    let name: String = match form {
        Either::Left(json) => json.name.to_owned(),
        Either::Right(form) => form.name.to_owned(),
    };

    format!("Welcome {}!", name)
}

Responder

It may be desirable to use a concrete type for a response with multiple branches. As long as both types implement Responder, so will the Either type, enabling it to be used as a handler’s return type.

All properties of a response are determined by the Responder branch returned.

use actix_web::{get, Either, Error, HttpResponse};

#[get("/")]
async fn index() -> Either<&'static str, Result<HttpResponse, Error>> {
    if 1 == 2 {
        // respond with Left variant
        Either::Left("Bad data")
    } else {
        // respond with Right variant
        Either::Right(
            Ok(HttpResponse::Ok()
                .content_type(mime::TEXT_HTML)
                .body("<p>Hello!</p>"))
        )
    }
}

Variants

Left(L)

A value of type L.

Right(R)

A value of type R.

Implementations

impl<T> Either<Form<T>, Json<T>>

pub fn into_inner(self) -> T

impl<T> Either<Json<T>, Form<T>>

pub fn into_inner(self) -> T

Trait Implementations

impl<L: Debug, R: Debug> Debug for Either<L, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

where L: FromRequest + 'static, R: FromRequest + 'static,

See here for example of usage as an extractor.

type Error = EitherExtractError<<L as FromRequest>::Error, <R as FromRequest>::Error>

The associated error which can be returned.

type Future = EitherExtractFut<L, R>

Future that resolves to a Self.

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

Create a Self from request parts asynchronously.

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

Create a Self from request head asynchronously.

impl<L: PartialEq, R: PartialEq> PartialEq for Either<L, R>

fn eq(&self, other: &Either<L, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

where L: Responder, R: Responder,

See here for example of usage as a handler return type.

type Body = EitherBody<<L as Responder>::Body, <R as Responder>::Body>

fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body>

Convert self to HttpResponse.

fn customize(self) -> CustomizeResponder<Self>

where Self: Sized,

Wraps responder to allow alteration of its response.

impl<L: Eq, R: Eq> Eq for Either<L, R>

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