Enum NullableResult

pub enum NullableResult<T, E> {
    Ok(T),
    Err(E),
    Null,
}

A replacement for Option<Result<T, E>> or Result<Option<T>, E>.

Sometimes, no value returned from an operation is not an error. It’s a special case that needs to be handled, but it’s separate from error handling. Wrapping an Option in a Result or vice versa can get very confusing very fast. Instead, use a NullableResult.

This is how it’s defined:

pub enum NullableResult<T, E> {
    Ok(T),
    Err(E),
    Null,
}

Convert to and From std Types

It defines the From trait for Option<Result<T, E>> and for Result<Option<T>, E> in both directions, so you can easily convert between the standard library types and back.

let opt_res: Option<Result<usize, isize>> = Some(Ok(4));
let nr: NullableResult<usize, isize> = NullableResult::from(opt_res);
let opt_res: Option<Result<_,_>> = nr.into();

It also defines From for [Option<T>] and for [Result<T, E>`].

let nr: NullableResult<_, isize> = NullableResult::from(Some(4));
let result: Result<usize, isize> = Ok(4);
let nr = NullableResult::from(result);

Unwrapping Conversions

There are also methods for unwrapping conversions. (i.e. convert to Option<T> or Result<T, E>. When converting a a Result, you need to provide an error value in case the NullableResult contains Null.

let nr = NullableResult::<usize, isize>::Ok(5);
let opt = nr.option();
let res = nr.result(-5);

There are also a few convenience methods.

let nr: NullableResult<usize, isize> = NullableResult::Ok(4);
let _ : Option<Result<usize, isize>> = nr.optional_result();
let _: Result<Option<usize>, isize> = nr.resulting_option();
let _: Result<usize, Option<isize>> = nr.result_optional_err();
let _: Result<usize, isize> = nr.result(-5); // need to provide default error value
let _: Result<usize, isize> = nr.result_with(|| 5 - 10); //closure that returns a default error

Variants

Ok(T)

Contains the success value

Err(E)

Contains the error value

Null

No value

Implementations

impl<T, E: Debug> NullableResult<T, E>

pub fn unwrap(self) -> T

Panics if it’s not Ok, otherwise returns the contained value.

impl<T: Default, E> NullableResult<T, E>

pub fn unwrap_or_default(self) -> T

Returns the contained value if it’s Ok, otherwise returns the default value for that type.

impl<T: Copy, E> NullableResult<&T, E>

pub fn copied(self) -> NullableResult<T, E>

Returns a NullableResult with the Ok part copied.

impl<T: Copy, E> NullableResult<&mut T, E>

pub fn copied(self) -> NullableResult<T, E>

Returns a NullableResult with the Ok part copied.

impl<T: Clone, E> NullableResult<&T, E>

pub fn cloned(self) -> NullableResult<T, E>

Returns a NullableResult with the Ok part cloned.

impl<T: Clone, E> NullableResult<&mut T, E>

pub fn cloned(self) -> NullableResult<T, E>

Returns a NullableResult with the Ok part cloned.

impl<T: Deref, E> NullableResult<T, E>

pub fn as_deref(&self) -> NullableResult<&T::Target, &E>

Coerce the Ok variant of the original result with Deref and returns the new NullableResult

impl<T, E> NullableResult<T, E>

pub fn is_ok(&self) -> bool

Returns true if this result is an Ok value

pub fn is_err(&self) -> bool

Returns true if this result is an Err value

pub fn is_null(&self) -> bool

Returns true if this result is a Null value

pub fn expect(self, msg: &str) -> T

Returns the contained Ok value, consuming self.

Panics

Panics if the value is not Ok with the provided message.

pub fn unwrap_or(self, item: T) -> T

Returns the contained value if it’s Ok, returns item otherwise.

pub fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T

Returns the contained value if it’s Ok, otherwise, it calls f and forwards its return value.

pub fn option(self) -> Option<T>

Returns an Option<T> consuming self, returns Null if the NullableResult contains Err.

pub fn optional_result(self) -> Option<Result<T, E>>

Return an Option<Result<T, E>> consuming self.

pub fn resulting_option(self) -> Result<Option<T>, E>

Return a Result<Option<T>, E> consuming self.

pub fn result(self, err: E) -> Result<T, E>

Returns a Result<T, E>, returns the provided err if the NullableResult contains Null

pub fn result_with<F: FnOnce() -> E>(self, f: F) -> Result<T, E>

Returns a Result<T, E>, if the NullableResult contains Ok or Err, the value is returned, otherwise, returns the result of f.

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> NullableResult<U, E>

Maps to a NullableResult with a different ok type.

pub fn map_err<U, F: FnOnce(E) -> U>(self, f: F) -> NullableResult<T, U>

Maps to a NullableResult with a different err type.

pub fn result_optional_err(self) -> Result<T, Option<E>>

Returns a Result with an optional error.

pub fn as_ref(&self) -> NullableResult<&T, &E>

Convert from a NullableResult<T, E> or &NullableResult<T, E> to a NullableResult<&T, &E>.

pub fn as_mut(&mut self) -> NullableResult<&mut T, &mut E>

Convert from a mut NullableResult<T, E> or &mut NullableResult<T, E> to a NullableResult<&mut T, &mut E>.

pub fn and<U>(self, res: NullableResult<U, E>) -> NullableResult<U, E>

If self is Ok, returns res, keeps the Err or Null from self otherwise.

pub fn and_then<U, F>(self, op: F) -> NullableResult<U, E>

where F: FnOnce(T) -> NullableResult<U, E>,

Calls op if the result is Ok, otherwise returns the Err or Null from self.

impl<T, E> NullableResult<NullableResult<T, E>, E>

pub fn flatten(self) -> NullableResult<T, E>

Convert from NullableResult<NullableResult<T, E>, E> to NullableResult<T, E>.

Trait Implementations

impl<T: Clone, E: Clone> Clone for NullableResult<T, E>

fn clone(&self) -> NullableResult<T, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, E: Debug> Debug for NullableResult<T, E>

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

Formats the value using the given formatter.

impl<T, E> Default for NullableResult<T, E>

fn default() -> Self

The default value is Null

impl<T, E> From<NullableResult<T, E>> for Option<Result<T, E>>

fn from(nr: NullableResult<T, E>) -> Self

Converts to this type from the input type.

impl<T, E> From<NullableResult<T, E>> for Result<Option<T>, E>

fn from(nr: NullableResult<T, E>) -> Self

Converts to this type from the input type.

impl<T, E> From<Option<Result<T, E>>> for NullableResult<T, E>

fn from(opt: Option<Result<T, E>>) -> Self

Converts to this type from the input type.

impl<T, E> From<Option<T>> for NullableResult<T, E>

fn from(opt: Option<T>) -> Self

Converts to this type from the input type.

impl<T, E> From<Result<Option<T>, E>> for NullableResult<T, E>

fn from(res: Result<Option<T>, E>) -> Self

Converts to this type from the input type.

impl<T, E> From<Result<T, E>> for NullableResult<T, E>

fn from(res: Result<T, E>) -> Self

Converts to this type from the input type.

impl<T, E> From<Result<T, Option<E>>> for NullableResult<T, E>

fn from(res: Result<T, Option<E>>) -> Self

Converts to this type from the input type.

impl<T, E, C> FromIterator<NullableResult<T, E>> for NullableResult<C, E>

where C: FromIterator<T>,

fn from_iter<I: IntoIterator<Item = NullableResult<T, E>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Hash, E: Hash> Hash for NullableResult<T, E>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord, E: Ord> Ord for NullableResult<T, E>

fn cmp(&self, other: &NullableResult<T, E>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, E: PartialEq> PartialEq for NullableResult<T, E>

fn eq(&self, other: &NullableResult<T, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, E: PartialOrd> PartialOrd for NullableResult<T, E>

fn partial_cmp(&self, other: &NullableResult<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy, E: Copy> Copy for NullableResult<T, E>

impl<T: Eq, E: Eq> Eq for NullableResult<T, E>

impl<T, E> StructuralPartialEq for NullableResult<T, E>