Enum Either

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

An Enum representing a value of one of two possible types.

Either<A, B> is particularly useful in service composition and layered architectures.

Either allows for conditional inclusion of layers in a service stack:

impl<T> SvcC<T> {
   fn layer<C>() -> impl FactoryLayer<C, T, Factory = Self> {
      layer_fn(|_: &C, inner| SvcC { inner })
   }

  fn opt_layer<C>(enabled: bool) -> Option<impl FactoryLayer<C, T, Factory = Self>> {
      if enabled {
          Some(layer_fn(|_: &C, inner| SvcC { inner }))
      } else {
          None
      }
   }
}

let stack = FactoryStack::new(config)
    .push(SvcAFactory::layer())
    .push(SvcBFactory::layer())
    .push(SvcC::opt_layer(true));  // Conditionally include SvcC

This pattern enables runtime control over the service composition, making it possible to dynamically include or exclude certain layers based on configuration or runtime conditions.

Variants

Left(A)

Right(B)

Implementations

impl<A, B> Either<A, B>

pub fn as_pin_ref(self: Pin<&Self>) -> Either<Pin<&A>, Pin<&B>>

Convert Pin<&Either<A, B>> to Either<Pin<&A>, Pin<&B>>, pinned projections of the inner variants.

pub fn as_pin_mut(self: Pin<&mut Self>) -> Either<Pin<&mut A>, Pin<&mut B>>

Convert Pin<&mut Either<A, B>> to Either<Pin<&mut A>, Pin<&mut B>>, pinned projections of the inner variants.

impl<T> Either<T, T>

pub fn into_inner(self) -> T

Trait Implementations

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

where A: AsyncMakeService, B: AsyncMakeService,

type Service = Either<<A as AsyncMakeService>::Service, <B as AsyncMakeService>::Service>

The type of service this factory creates.

type Error = Either<<A as AsyncMakeService>::Error, <B as AsyncMakeService>::Error>

The type of error that can occur during service creation.

async fn make_via_ref( &self, old: Option<&Self::Service>, ) -> Result<Self::Service, Self::Error>

Asynchronously creates a new service, optionally using an existing service as a reference.

fn make(&self) -> impl Future<Output = Result<Self::Service, Self::Error>>

Asynchronously creates a new service without referencing an existing one.

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

fn clone(&self) -> Either<A, B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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: Display, B: Display> Display for Either<A, B>

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

Formats the value using the given formatter.

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

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<C, F, FLA, FLB> FactoryLayer<C, F> for Either<FLA, FLB>

where FLA: FactoryLayer<C, F>, FLB: FactoryLayer<C, F>,

type Factory = Either<<FLA as FactoryLayer<C, F>>::Factory, <FLB as FactoryLayer<C, F>>::Factory>

The type of factory this layer produces.

fn layer(&self, config: &C, inner: F) -> Self::Factory

Creates a new factory wrapper.

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

where A: Future, B: Future<Output = A::Output>,

type Output = <A as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

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

where A: MakeService, B: MakeService,

type Service = Either<<A as MakeService>::Service, <B as MakeService>::Service>

The type of service this factory creates.

type Error = Either<<A as MakeService>::Error, <B as MakeService>::Error>

The type of error that can occur during service creation.

fn make_via_ref( &self, old: Option<&Self::Service>, ) -> Result<Self::Service, Self::Error>

Creates a new service, optionally using an existing service as a reference.

fn make(&self) -> Result<Self::Service, Self::Error>

Creates a new service without referencing an existing one.

impl<A, B, R> Service<R> for Either<A, B>

where A: Service<R>, B: Service<R, Response = A::Response, Error = A::Error>,

type Response = <A as Service<R>>::Response

The type of response returned by this service.

type Error = <A as Service<R>>::Error

The type of error that this service can produce.

fn call( &self, req: R, ) -> impl Future<Output = Result<Self::Response, Self::Error>>

Asynchronously process the request and return the response.