Enum actix_web::Either

pub enum Either<A, B> {
    A(A),
    B(B),
}

Combines two different responder types into a single type

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

type RegisterResult = Either<HttpResponse, Result<HttpResponse, Error>>;

fn index() -> RegisterResult {
    if is_a_variant() {
        // <- choose left variant
        Either::A(HttpResponse::BadRequest().body("Bad data"))
    } else {
        Either::B(
            // <- Right variant
            Ok(HttpResponse::Ok()
                .content_type("text/html")
                .body("Hello!"))
        )
    }
}

Variants

A(A)

First branch of the type

B(B)

Second branch of the type

Trait Implementations

impl<A: Debug, B: Debug> Debug for Either<A, B>

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

Formats the value using the given formatter.

impl<A: PartialEq, B: PartialEq> PartialEq<Either<A, B>> for Either<A, B>

fn eq(&self, other: &Either<A, B>) -> bool

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

fn ne(&self, other: &Either<A, B>) -> bool

This method tests for !=.

impl<A, B> Responder for Either<A, B> where
    A: Responder,
    B: Responder, 

type Error = Error

The associated error which can be returned.

type Future = EitherResponder<A, B>

The future response value.

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

Convert itself to AsyncResult or Error.

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

Override a status code for a Responder.

fn with_header<K, V>(self, key: K, value: V) -> CustomResponder<Self> where
    Self: Sized,
    HeaderName: TryFrom<K>,
    <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
    V: IntoHeaderValue, 

Add header to the Responder's response.

impl<A, B> StructuralPartialEq for Either<A, B>