```
pub enum Outcome<S, E, F> {
Success(S),
Failure(E),
Forward(F),
}
```

## Expand description

An enum representing success (`Success`

), failure (`Failure`

), or
forwarding (`Forward`

).

See the top level documentation for detailed information.

## Variants§

### Success(S)

Contains the success value.

### Failure(E)

Contains the failure error value.

### Forward(F)

Contains the value to forward on.

## Implementations§

source§### impl<S, E, F> Outcome<S, E, F>

### impl<S, E, F> Outcome<S, E, F>

source#### pub fn is_success(&self) -> bool

#### pub fn is_success(&self) -> bool

Return true if this `Outcome`

is a `Success`

.

##### §Examples

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.is_success(), true);
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.is_success(), false);
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.is_success(), false);
```

source#### pub fn is_failure(&self) -> bool

#### pub fn is_failure(&self) -> bool

Return true if this `Outcome`

is a `Failure`

.

##### §Examples

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.is_failure(), false);
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.is_failure(), true);
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.is_failure(), false);
```

source#### pub fn is_forward(&self) -> bool

#### pub fn is_forward(&self) -> bool

Return true if this `Outcome`

is a `Forward`

.

##### §Examples

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.is_forward(), false);
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.is_forward(), false);
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.is_forward(), true);
```

source#### pub fn succeeded(self) -> Option<S>

#### pub fn succeeded(self) -> Option<S>

Converts from `Outcome<S, E, F>`

to `Option<S>`

.

Returns the `Some`

of the `Success`

if this is a `Success`

, otherwise
returns `None`

. `self`

is consumed, and all other values are discarded.

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.succeeded(), Some(10));
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.succeeded(), None);
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.succeeded(), None);
```

source#### pub fn failed(self) -> Option<E>

#### pub fn failed(self) -> Option<E>

Converts from `Outcome<S, E, F>`

to `Option<E>`

.

Returns the `Some`

of the `Failure`

if this is a `Failure`

, otherwise
returns `None`

. `self`

is consumed, and all other values are discarded.

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.failed(), None);
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.failed(), Some("Hi! I'm an error."));
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.failed(), None);
```

source#### pub fn forwarded(self) -> Option<F>

#### pub fn forwarded(self) -> Option<F>

Converts from `Outcome<S, E, F>`

to `Option<F>`

.

Returns the `Some`

of the `Forward`

if this is a `Forward`

, otherwise
returns `None`

. `self`

is consumed, and all other values are discarded.

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.forwarded(), None);
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.forwarded(), None);
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.forwarded(), Some(25));
```

source#### pub fn success_or<T>(self, value: T) -> Result<S, T>

#### pub fn success_or<T>(self, value: T) -> Result<S, T>

Converts from `Outcome<S, E, F>`

to `Result<S, T>`

for a given `T`

.

Returns `Ok`

with the `Success`

value if this is a `Success`

, otherwise
returns an `Err`

with the provided value. `self`

is consumed, and all
other values are discarded.

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.success_or(false), Ok(10));
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.success_or(false), Err(false));
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.success_or("whoops"), Err("whoops"));
```

source#### pub fn success_or_else<T, V: FnOnce() -> T>(self, f: V) -> Result<S, T>

#### pub fn success_or_else<T, V: FnOnce() -> T>(self, f: V) -> Result<S, T>

Converts from `Outcome<S, E, F>`

to `Result<S, T>`

for a given `T`

produced from a supplied function or closure.

Returns `Ok`

with the `Success`

value if this is a `Success`

, otherwise
returns an `Err`

with the result of calling `f`

. `self`

is consumed, and
all other values are discarded.

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.success_or_else(|| false), Ok(10));
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.success_or_else(|| false), Err(false));
let x: Outcome<i32, &str, usize> = Forward(25);
assert_eq!(x.success_or_else(|| "whoops"), Err("whoops"));
```

source#### pub fn as_ref(&self) -> Outcome<&S, &E, &F>

#### pub fn as_ref(&self) -> Outcome<&S, &E, &F>

Converts from `Outcome<S, E, F>`

to `Outcome<&S, &E, &F>`

.

```
let x: Outcome<i32, &str, usize> = Success(10);
assert_eq!(x.as_ref(), Success(&10));
let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error.");
assert_eq!(x.as_ref(), Failure(&"Hi! I'm an error."));
```

source#### pub fn map<T, M: FnOnce(S) -> T>(self, f: M) -> Outcome<T, E, F>

#### pub fn map<T, M: FnOnce(S) -> T>(self, f: M) -> Outcome<T, E, F>

Maps an `Outcome<S, E, F>`

to an `Outcome<T, E, F>`

by applying the
function `f`

to the value of type `S`

in `self`

if `self`

is an
`Outcome::Success`

.

```
let x: Outcome<i32, &str, usize> = Success(10);
let mapped = x.map(|v| if v == 10 { "10" } else { "not 10" });
assert_eq!(mapped, Success("10"));
```

source#### pub fn map_failure<T, M: FnOnce(E) -> T>(self, f: M) -> Outcome<S, T, F>

#### pub fn map_failure<T, M: FnOnce(E) -> T>(self, f: M) -> Outcome<S, T, F>

Maps an `Outcome<S, E, F>`

to an `Outcome<S, T, F>`

by applying the
function `f`

to the value of type `E`

in `self`

if `self`

is an
`Outcome::Failure`

.

```
let x: Outcome<i32, &str, usize> = Failure("hi");
let mapped = x.map_failure(|v| if v == "hi" { 10 } else { 0 });
assert_eq!(mapped, Failure(10));
```

source#### pub fn map_forward<T, M: FnOnce(F) -> T>(self, f: M) -> Outcome<S, E, T>

#### pub fn map_forward<T, M: FnOnce(F) -> T>(self, f: M) -> Outcome<S, E, T>

Maps an `Outcome<S, E, F>`

to an `Outcome<S, E, T>`

by applying the
function `f`

to the value of type `F`

in `self`

if `self`

is an
`Outcome::Forward`

.

```
let x: Outcome<i32, &str, usize> = Forward(5);
let mapped = x.map_forward(|v| if v == 5 { "a" } else { "b" });
assert_eq!(mapped, Forward("a"));
```

source#### pub fn and_then<T, M: FnOnce(S) -> Outcome<T, E, F>>(
self,
f: M,
) -> Outcome<T, E, F>

#### pub fn and_then<T, M: FnOnce(S) -> Outcome<T, E, F>>( self, f: M, ) -> Outcome<T, E, F>

Maps an `Outcome<S, E, F>`

to an `Outcome<T, E, F>`

by applying the
function `f`

to the value of type `S`

in `self`

if `self`

is an
`Outcome::Success`

.

##### §Examples

```
let x: Outcome<i32, &str, bool> = Success(10);
let mapped = x.and_then(|v| match v {
10 => Success("10"),
1 => Forward(false),
_ => Failure("30")
});
assert_eq!(mapped, Success("10"));
```

source#### pub fn failure_then<T, M: FnOnce(E) -> Outcome<S, T, F>>(
self,
f: M,
) -> Outcome<S, T, F>

#### pub fn failure_then<T, M: FnOnce(E) -> Outcome<S, T, F>>( self, f: M, ) -> Outcome<S, T, F>

Maps an `Outcome<S, E, F>`

to an `Outcome<S, T, F>`

by applying the
function `f`

to the value of type `E`

in `self`

if `self`

is an
`Outcome::Failure`

.

##### §Examples

```
let x: Outcome<i32, &str, bool> = Failure("hi");
let mapped = x.failure_then(|v| match v {
"hi" => Failure(10),
"test" => Forward(false),
_ => Success(10)
});
assert_eq!(mapped, Failure(10));
```

source#### pub fn forward_then<T, M: FnOnce(F) -> Outcome<S, E, T>>(
self,
f: M,
) -> Outcome<S, E, T>

#### pub fn forward_then<T, M: FnOnce(F) -> Outcome<S, E, T>>( self, f: M, ) -> Outcome<S, E, T>

Maps an `Outcome<S, E, F>`

to an `Outcome<S, E, T>`

by applying the
function `f`

to the value of type `F`

in `self`

if `self`

is an
`Outcome::Forward`

.

##### §Examples

```
let x: Outcome<i32, &str, Option<bool>> = Forward(Some(false));
let mapped = x.forward_then(|v| match v {
Some(true) => Success(10),
Some(false) => Forward(20),
None => Failure("10")
});
assert_eq!(mapped, Forward(20));
```

source§### impl<'r> Outcome<Response<'r>, Status, Data>

### impl<'r> Outcome<Response<'r>, Status, Data>

source#### pub fn from<T: Responder<'r>>(req: &Request<'_>, responder: T) -> Outcome<'r>

#### pub fn from<T: Responder<'r>>(req: &Request<'_>, responder: T) -> Outcome<'r>

Return the `Outcome`

of response to `req`

from `responder`

.

If the responder returns `Ok`

, an outcome of `Success`

is
returned with the response. If the responder returns `Err`

, an
outcome of `Failure`

is returned with the status code.

##### §Example

```
use rocket::{Request, Data};
use rocket::handler::Outcome;
fn str_responder(req: &Request, _: Data) -> Outcome<'static> {
Outcome::from(req, "Hello, world!")
}
```

source#### pub fn from_or_forward<T>(
req: &Request<'_>,
data: Data,
responder: T,
) -> Outcome<'r>where
T: Responder<'r>,

#### pub fn from_or_forward<T>(
req: &Request<'_>,
data: Data,
responder: T,
) -> Outcome<'r>where
T: Responder<'r>,

Return the `Outcome`

of response to `req`

from `responder`

.

If the responder returns `Ok`

, an outcome of `Success`

is
returned with the response. If the responder returns `Err`

, an
outcome of `Forward`

is returned.

##### §Example

```
use rocket::{Request, Data};
use rocket::handler::Outcome;
fn str_responder(req: &Request, data: Data) -> Outcome<'static> {
Outcome::from_or_forward(req, data, "Hello, world!")
}
```

source#### pub fn failure(code: Status) -> Outcome<'static>

#### pub fn failure(code: Status) -> Outcome<'static>

Return an `Outcome`

of `Failure`

with the status code `code`

. This is
equivalent to `Outcome::Failure(code)`

.

This method exists to be used during manual routing where
`rocket::handler::Outcome`

is imported instead of `rocket::Outcome`

.

##### §Example

```
use rocket::{Request, Data};
use rocket::handler::Outcome;
use rocket::http::Status;
fn bad_req_route(_: &Request, _: Data) -> Outcome<'static> {
Outcome::failure(Status::BadRequest)
}
```

source#### pub fn forward(data: Data) -> Outcome<'static>

#### pub fn forward(data: Data) -> Outcome<'static>

Return an `Outcome`

of `Forward`

with the data `data`

. This is
equivalent to `Outcome::Forward(data)`

.

This method exists to be used during manual routing where
`rocket::handler::Outcome`

is imported instead of `rocket::Outcome`

.

##### §Example

```
use rocket::{Request, Data};
use rocket::handler::Outcome;
fn always_forward(_: &Request, data: Data) -> Outcome<'static> {
Outcome::forward(data)
}
```

## Trait Implementations§

source§### impl<Y, S, E: From<Y>, F> FromResidual<Result<Infallible, Y>> for Outcome<S, E, F>

### impl<Y, S, E: From<Y>, F> FromResidual<Result<Infallible, Y>> for Outcome<S, E, F>

source§#### fn from_residual(r: Result<Infallible, Y>) -> Self

#### fn from_residual(r: Result<Infallible, Y>) -> Self

`try_trait_v2`

)`Residual`

type. Read moresource§### impl<S: Ord, E: Ord, F: Ord> Ord for Outcome<S, E, F>

### impl<S: Ord, E: Ord, F: Ord> Ord for Outcome<S, E, F>

1.21.0 · source§#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

source§### impl<S: PartialEq, E: PartialEq, F: PartialEq> PartialEq for Outcome<S, E, F>

### impl<S: PartialEq, E: PartialEq, F: PartialEq> PartialEq for Outcome<S, E, F>

source§### impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd for Outcome<S, E, F>

### impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd for Outcome<S, E, F>

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl<A, B, C> Try for Outcome<A, B, C>

### impl<A, B, C> Try for Outcome<A, B, C>

§#### type Output = A

#### type Output = A

`try_trait_v2`

)`?`

when *not*short-circuiting.

§#### type Residual = Outcome<!, B, C>

#### type Residual = Outcome<!, B, C>

`try_trait_v2`

)`FromResidual::from_residual`

as part of `?`

when short-circuiting. Read moresource§#### fn from_output(x: Self::Output) -> Self

#### fn from_output(x: Self::Output) -> Self

`try_trait_v2`

)`Output`

type. Read moresource§#### fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

#### fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

`try_trait_v2`

)`?`

to decide whether the operator should produce a value
(because this returned `ControlFlow::Continue`

)
or propagate a value back to the caller
(because this returned `ControlFlow::Break`

). Read more### impl<S: Copy, E: Copy, F: Copy> Copy for Outcome<S, E, F>

### impl<S: Eq, E: Eq, F: Eq> Eq for Outcome<S, E, F>

### impl<S, E, F> StructuralPartialEq for Outcome<S, E, F>

## Auto Trait Implementations§

### impl<S, E, F> Freeze for Outcome<S, E, F>

### impl<S, E, F> RefUnwindSafe for Outcome<S, E, F>

### impl<S, E, F> Send for Outcome<S, E, F>

### impl<S, E, F> Sync for Outcome<S, E, F>

### impl<S, E, F> Unpin for Outcome<S, E, F>

### impl<S, E, F> UnwindSafe for Outcome<S, E, F>

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

source§### impl<T> CloneToUninit for Twhere
T: Copy,

### impl<T> CloneToUninit for Twhere
T: Copy,

source§#### unsafe fn clone_to_uninit(&self, dst: *mut T)

#### unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)source§### impl<T> CloneToUninit for Twhere
T: Clone,

### impl<T> CloneToUninit for Twhere
T: Clone,

source§#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

source§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.