Struct Result

Source

pub struct Result<T, E, K = ()>(/* private fields */);

Expand description

A wrapper of core::result::Result, utilized for specific purposes.

This struct uses the FromParam trait to implement the FromFormField trait (only impl the from_value method), allowing it to serve as the error type for subsequent checks.
This struct implements the Deserialize trait, allowing it to serve as the error type for subsequent checks.

Implementations§

Source §

impl<T, E, K> Result<T, E, K>

Source

pub const fn new(result: Result<T, E>) -> Self

Create a new instance.

Source

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

Convert this instance into core::result::Result.

Source

pub const fn as_std_result(&self) -> &Result<T, E>

Get the reference of the core::result::Result instance inside this.

Methods from Deref<Target = Result<T, E>>§

1.0.0 · Source

pub fn is_ok(&self) -> bool

Returns true if the result is Ok.

§Examples

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);

1.0.0 · Source

pub fn is_err(&self) -> bool

Returns true if the result is Err.

§Examples

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);

1.0.0 · Source

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

Converts from &Result<T, E> to Result<&T, &E>.

Produces a new Result, containing a reference into the original, leaving the original in place.

§Examples

let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));

1.0.0 · Source

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

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

§Examples

fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);

1.47.0 · Source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

Coerces the Ok variant of the original Result via Deref and returns the new Result.

§Examples

let x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&str, &u32> = Ok("hello");
assert_eq!(x.as_deref(), y);

let x: Result<String, u32> = Err(42);
let y: Result<&str, &u32> = Err(&42);
assert_eq!(x.as_deref(), y);

1.47.0 · Source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

Coerces the Ok variant of the original Result via DerefMut and returns the new Result.

§Examples

let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

1.0.0 · Source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

The iterator yields one value if the result is Result::Ok, otherwise none.

§Examples

let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);

1.0.0 · Source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

The iterator yields one value if the result is Result::Ok, otherwise none.

§Examples

let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);

Trait Implementations§

Source §

impl<T: Clone, E: Clone, K: Clone> Clone for Result<T, E, K>

Source §

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

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more

Source §

impl<T: Copy, E: Copy, K: Copy> Copy for Result<T, E, K>

Source §

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

Source §

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

Formats the value using the given formatter. Read more

Source §

impl<T, E> Deref for Result<T, E>

Source §

type Target = Result<T, E>

The resulting type after dereferencing.

Source §

fn deref(&self) -> &Self::Target

Dereferences the value.

Source §

impl<T, E> DerefMut for Result<T, E>

Source §

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

Source §