# tokio_util::either::Either - Rust
API documentation for the Rust `Either` enum in crate `tokio_util`.
Keywords: rust, rustlang, rust-lang, Either

# Enum tokio_util::either::Either [−] [src]

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

Combines two different futures, streams, or sinks having the same associated types into a single type.

This type implements common asynchronous traits such as `Future` and those in Tokio.

# Example

The following code will not work:

ⓘ

    #[tokio::main]
    async fn main() {
        let result = if some_condition() {
            some_async_function()
        } else {
            other_async_function() // <- Will print: "`if` and `else` have incompatible types"
        };

        println!("Result is {}", result.await);
    }

When the output type is the same, we can wrap each future in `Either` to avoid the issue:

    use tokio_util::either::Either;

    #[tokio::main]
    async fn main() {
        let result = if some_condition() {
            Either::Left(some_async_function())
        } else {
            Either::Right(other_async_function())
        };

        let value = result.await;
        println!("Result is {}", value);
    }

## Variants

`Left(L)`
`Right(R)`

## Trait Implementations

### `impl<L, R> AsyncBufRead for Either<L, R> where
L: AsyncBufRead,
R: AsyncBufRead,` [src]

#### `fn poll_fill_buf(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<&[u8]>>` [src]

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more

#### `fn consume(self: Pin<&mut Self>, amt: usize)` [src]

Tells this buffer that `amt` bytes have been consumed from the buffer, so they should no longer be returned in calls to `poll_read`. Read more

### `impl<L, R> AsyncRead for Either<L, R> where
L: AsyncRead,
R: AsyncRead,` [src]

#### `fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<()>>` [src]

Attempts to read from the `AsyncRead` into `buf`. Read more

### `impl<L, R> AsyncSeek for Either<L, R> where
L: AsyncSeek,
R: AsyncSeek,` [src]

#### `fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> Result<()>` [src]

Attempts to seek to an offset, in bytes, in a stream. Read more

#### `fn poll_complete(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<u64>>` [src]

Waits for a seek operation to complete. Read more

### `impl<L, R> AsyncWrite for Either<L, R> where
L: AsyncWrite,
R: AsyncWrite,` [src]

#### `fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>` [src]

Attempt to write bytes from `buf` into the object. Read more

#### `fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>` [src]

Attempts to flush the object, ensuring that any buffered data reach their destination. Read more

#### `fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>` [src]

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. Read more

#### `pub fn poll_write_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>` [src]

Like `poll_write`, except that it writes from a slice of buffers. Read more

#### `pub fn is_write_vectored(&self) -> bool` [src]

Determines if this writer has an efficient `poll_write_vectored` implementation. Read more

### `impl<L: Clone, R: Clone> Clone for Either<L, R>` [src]

#### `fn clone(&self) -> Either<L, R>ⓘ

### Notable traits for Either<L, R>

`impl<L, R, O> Future for Either<L, R> where
L: Future<Output = O>,
R: Future<Output = O>, type Output = O;`
` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl<L: Debug, R: Debug> Debug for Either<L, R>` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<L, R, O> Future for Either<L, R> where
L: Future<Output = O>,
R: Future<Output = O>,` [src]

#### `type Output = O`

The type of value produced on completion.

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

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

### `impl<L, R> Stream for Either<L, R> where
L: Stream,
R: Stream<Item = L::Item>,` [src]

#### `type Item = L::Item`

Values yielded by the stream.

#### `fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>` [src]

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning `None` if the stream is exhausted. Read more

#### `pub fn size_hint(&self) -> (usize, Option<usize>)` [src]

Returns the bounds on the remaining length of the stream. Read more

## Auto Trait Implementations

### `impl<L, R> RefUnwindSafe for Either<L, R> where
L: RefUnwindSafe,
R: RefUnwindSafe,` [src]

### `impl<L, R> Send for Either<L, R> where
L: Send,
R: Send,` [src]

### `impl<L, R> Sync for Either<L, R> where
L: Sync,
R: Sync,` [src]

### `impl<L, R> Unpin for Either<L, R> where
L: Unpin,
R: Unpin,` [src]

### `impl<L, R> UnwindSafe for Either<L, R> where
L: UnwindSafe,
R: UnwindSafe,` [src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<R> AsyncBufReadExt for R where
R: AsyncBufRead + ?Sized,` [src]

#### `pub fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntil<'a, Self> where
Self: Unpin,` [src]

Reads all bytes into `buf` until the delimiter `byte` or EOF is reached. Read more

#### `pub fn read_line(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self> where
Self: Unpin,` [src]

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided buffer. Read more

#### `pub fn split(self, byte: u8) -> Split<Self> where
Self: Unpin,` [src]

Returns a stream of the contents of this reader split on the byte `byte`. Read more

#### `pub fn lines(self) -> Lines<Self>` [src]

Returns a stream over the lines of this reader. This method is the async equivalent to `BufRead::lines`. Read more

### `impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized,` [src]

#### `pub fn chain<R>(self, next: R) -> Chain<Self, R> where
R: AsyncRead,` [src]

Creates a new `AsyncRead` instance that chains this stream with `next`. Read more

#### `pub fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin,` [src]

Pulls some bytes from this source into the specified buffer, returning how many bytes were read. Read more

#### `pub fn read_buf<B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B> where
Self: Unpin,
B: BufMut,` [src]

Pulls some bytes from this source into the specified buffer, advancing the buffer's internal cursor. Read more

#### `pub fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin,` [src]

Reads the exact number of bytes required to fill `buf`. Read more

#### `pub fn read_u8(&'a mut self) -> ReadU8<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 8 bit integer from the underlying reader. Read more

#### `pub fn read_i8(&'a mut self) -> ReadI8<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 8 bit integer from the underlying reader. Read more

#### `pub fn read_u16(&'a mut self) -> ReadU16<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 16-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i16(&'a mut self) -> ReadI16<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 16-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u32(&'a mut self) -> ReadU32<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 32-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i32(&'a mut self) -> ReadI32<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 32-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u64(&'a mut self) -> ReadU64<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 64-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i64(&'a mut self) -> ReadI64<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 64-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u128(&'a mut self) -> ReadU128<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 128-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i128(&'a mut self) -> ReadI128<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 128-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u16_le(&'a mut self) -> ReadU16Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 16-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i16_le(&'a mut self) -> ReadI16Le<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 16-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_u32_le(&'a mut self) -> ReadU32Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 32-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i32_le(&'a mut self) -> ReadI32Le<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 32-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_u64_le(&'a mut self) -> ReadU64Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 64-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i64_le(&'a mut self) -> ReadI64Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 64-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_u128_le(&'a mut self) -> ReadU128Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 128-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i128_le(&'a mut self) -> ReadI128Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 128-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEnd<'a, Self> where
Self: Unpin,` [src]

Reads all bytes until EOF in this source, placing them into `buf`. Read more

#### `pub fn read_to_string(
&'a mut self,
dst: &'a mut String
) -> ReadToString<'a, Self> where
Self: Unpin,` [src]

Reads all bytes until EOF in this source, appending them to `buf`. Read more

#### `pub fn take(self, limit: u64) -> Take<Self>` [src]

Creates an adaptor which reads at most `limit` bytes from it. Read more

### `impl<S> AsyncSeekExt for S where
S: AsyncSeek + ?Sized,` [src]

#### `pub fn seek(&mut self, pos: SeekFrom) -> Seek<'_, Self> where
Self: Unpin,` [src]

Creates a future which will seek an IO object, and then yield the new position in the object and the object itself. Read more

### `impl<W> AsyncWriteExt for W where
W: AsyncWrite + ?Sized,` [src]

#### `pub fn write(&'a mut self, src: &'a [u8]) -> Write<'a, Self> where
Self: Unpin,` [src]

Writes a buffer into this writer, returning how many bytes were written. Read more

#### `pub fn write_buf<B>(&'a mut self, src: &'a mut B) -> WriteBuf<'a, Self, B> where
Self: Unpin,
B: Buf,` [src]

Writes a buffer into this writer, advancing the buffer's internal cursor. Read more

#### `pub fn write_all(&'a mut self, src: &'a [u8]) -> WriteAll<'a, Self> where
Self: Unpin,` [src]

Attempts to write an entire buffer into this writer. Read more

#### `pub fn write_u8(&'a mut self, n: u8) -> WriteU8<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 8-bit integer to the underlying writer. Read more

#### `pub fn write_i8(&'a mut self, n: i8) -> WriteI8<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 8-bit integer to the underlying writer. Read more

#### `pub fn write_u16(&'a mut self, n: u16) -> WriteU16<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 16-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i16(&'a mut self, n: i16) -> WriteI16<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 16-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u32(&'a mut self, n: u32) -> WriteU32<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 32-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i32(&'a mut self, n: i32) -> WriteI32<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 32-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u64(&'a mut self, n: u64) -> WriteU64<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 64-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i64(&'a mut self, n: i64) -> WriteI64<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 64-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u128(&'a mut self, n: u128) -> WriteU128<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 128-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i128(&'a mut self, n: i128) -> WriteI128<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 128-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u16_le(&'a mut self, n: u16) -> WriteU16Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 16-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i16_le(&'a mut self, n: i16) -> WriteI16Le<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 16-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_u32_le(&'a mut self, n: u32) -> WriteU32Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 32-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i32_le(&'a mut self, n: i32) -> WriteI32Le<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 32-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_u64_le(&'a mut self, n: u64) -> WriteU64Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 64-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i64_le(&'a mut self, n: i64) -> WriteI64Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 64-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_u128_le(&'a mut self, n: u128) -> WriteU128Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 128-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i128_le(&'a mut self, n: i128) -> WriteI128Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 128-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn flush(&mut self) -> Flush<'_, Self> where
Self: Unpin,` [src]

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

#### `pub fn shutdown(&mut self) -> Shutdown<'_, Self> where
Self: Unpin,` [src]

Shuts down the output stream, ensuring that the value can be dropped cleanly. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<F> IntoFuture for F where
F: Future,` [src]

#### `type Output = <F as Future>::Output`

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

The output that the future will produce on completion.

#### `type Future = F`

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

Which kind of future are we turning this into?

#### `pub fn into_future(self) -> <F as IntoFuture>::Future` [src]

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

Creates a future from a value.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized,` [src]

#### `type Ok = T`

The type of successful values yielded by this future

#### `type Error = E`

The type of failures yielded by this future

#### `pub fn try_poll(
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>` [src]

Poll this `TryFuture` as if it were a `Future`. Read more

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.

### `impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,` [src]

#### `type Ok = T`

The type of successful values yielded by this future

#### `type Error = E`

The type of failures yielded by this future

#### `pub fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>` [src]

Poll this `TryStream` as if it were a `Stream`. Read more