Enum 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 URL-encoded.
#[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: Eq, R: Eq> Eq for Either<L, R>

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: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

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: PartialEq, R: PartialEq> StructuralPartialEq for Either<L, R>