Enum actix_web::Either

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

Combines two extractor or responder types into a single type.

Can be converted to and from an either::Either.

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 desireable 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> From<Either<L, R>> for Either<L, R>

fn from(val: Either<L, R>) -> Self

Performs the conversion.

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::Error, R::Error>

The associated error which can be returned.

type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>

Future that resolves to a Self.

type Config = ()

Configuration for this extractor.

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.

fn configure<F>(f: F) -> Self::Config where
    F: FnOnce(Self::Config) -> Self::Config, 

Create and configure config instance.

impl<L: PartialEq, R: PartialEq> PartialEq<Either<L, R>> 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: &Either<L, R>) -> bool

This method tests for !=.

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

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

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

Convert self to HttpResponse.

fn with_status(self, status: StatusCode) -> CustomResponder<Self> where
    Self: Sized, 

Override a status code for a Responder.

fn with_header<H>(self, header: H) -> CustomResponder<Self> where
    Self: Sized,
    H: IntoHeaderPair, 

Insert header to the final response.

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