Result in std::result - Rust (original) (raw)
pub enum Result<T, E> {
Ok(T),
Err(E),
}Expand description
Contains the success value
Contains the error value
1.0.0 (const: 1.48.0) · source
Returns true if the result is Ok.
Basic usage:
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 (const: 1.48.0) · source
Returns true if the result is Err.
Basic usage:
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);Converts from Result<T, E> to Option.
Converts self into an Option, consuming self, and discarding the error, if any.
Basic usage:
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));
let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);Converts from Result<T, E> to Option.
Converts self into an Option, consuming self, and discarding the success value, if any.
Basic usage:
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.err(), None);
let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.err(), Some("Nothing here"));1.0.0 (const: 1.48.0) · source
Converts from &Result<T, E> to Result<&T, &E>.
Produces a new Result, containing a reference into the original, leaving the original in place.
Basic usage:
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"));Converts from &mut Result<T, E> to Result<&mut T, &mut E>.
Basic usage:
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);Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value, leaving an Err value untouched.
This function can be used to compose the results of two functions.
Print the numbers on each line of a string multiplied by two.
let line = "1\n2\n3\n4\n";
for num in line.lines() {
match num.parse::<i32>().map(|i| i * 2) {
Ok(n) => println!("{}", n),
Err(..) => {}
}
}Returns the provided default (if Err), or applies a function to the contained value (if Ok),
Arguments passed to map_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use map_or_else, which is lazily evaluated.
let x: Result<_, &str> = Ok("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);
let x: Result<&str, _> = Err("bar");
assert_eq!(x.map_or(42, |v| v.len()), 42);Maps a Result<T, E> to U by applying fallback function default to a contained Err value, or function f to a contained Ok value.
This function can be used to unpack a successful result while handling an error.
Basic usage:
let k = 21;
let x : Result<_, &str> = Ok("foo");
assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);
let x : Result<&str, _> = Err("bar");
assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value, leaving an Ok value untouched.
This function can be used to pass through a successful result while handling an error.
Basic usage:
fn stringify(x: u32) -> String { format!("error code: {}", x) }
let x: Result<u32, u32> = Ok(2);
assert_eq!(x.map_err(stringify), Ok(2));
let x: Result<u32, u32> = Err(13);
assert_eq!(x.map_err(stringify), Err("error code: 13".to_string()));🔬 This is a nightly-only experimental API. (result_option_inspect #91345)
Calls the provided closure with a reference to the contained value (if Ok).
#![feature(result_option_inspect)]
let x: u8 = "4"
.parse::<u8>()
.inspect(|x| println!("original: {}", x))
.map(|x| x.pow(3))
.expect("failed to parse number");🔬 This is a nightly-only experimental API. (result_option_inspect #91345)
Calls the provided closure with a reference to the contained error (if Err).
#![feature(result_option_inspect)]
use std::{fs, io};
fn read() -> io::Result<String> {
fs::read_to_string("address.txt")
.inspect_err(|e| eprintln!("failed to read file: {}", e))
}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 Derefand returns the new Result.
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);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 DerefMutand returns the new Result.
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);Returns an iterator over the possibly contained value.
The iterator yields one value if the result is Result::Ok, otherwise none.
Basic usage:
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);Returns a mutable iterator over the possibly contained value.
The iterator yields one value if the result is Result::Ok, otherwise none.
Basic usage:
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);Returns the contained Ok value, consuming the self value.
Panics if the value is an Err, with a panic message including the passed message, and the content of the Err.
Basic usage:
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`Returns the contained Ok value, consuming the self value.
Because this function may panic, its use is generally discouraged. Instead, prefer to use pattern matching and handle the Errcase explicitly, or call unwrap_or, unwrap_or_else, orunwrap_or_default.
Panics if the value is an Err, with a panic message provided by theErr’s value.
Basic usage:
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`Returns the contained Ok value or a default
Consumes the self argument then, if Ok, returns the contained value, otherwise if Err, returns the default value for that type.
Converts a string to an integer, turning poorly-formed strings into 0 (the default value for integers). parse converts a string to any other type that implements FromStr, returning anErr on error.
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();
assert_eq!(1909, good_year);
assert_eq!(0, bad_year);Returns the contained Err value, consuming the self value.
Panics if the value is an Ok, with a panic message including the passed message, and the content of the Ok.
Basic usage:
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`Returns the contained Err value, consuming the self value.
Panics if the value is an Ok, with a custom panic message provided by the Ok’s value.
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");🔬 This is a nightly-only experimental API. (unwrap_infallible #61695)
Returns the contained Ok value, but never panics.
Unlike unwrap, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of unwrap as a maintainability safeguard that will fail to compile if the error type of the Result is later changed to an error that can actually occur.
Basic usage:
fn only_good_news() -> Result<String, !> {
Ok("this is fine".into())
}
let s: String = only_good_news().into_ok();
println!("{}", s);🔬 This is a nightly-only experimental API. (unwrap_infallible #61695)
Returns the contained Err value, but never panics.
Unlike unwrap_err, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of unwrap_err as a maintainability safeguard that will fail to compile if the ok type of the Result is later changed to a type that can actually occur.
Basic usage:
fn only_bad_news() -> Result<!, String> {
Err("Oops, it failed".into())
}
let error: String = only_bad_news().into_err();
println!("{}", error);Returns res if the result is Ok, otherwise returns the Err value of self.
Basic usage:
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));
let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));
let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));Calls op if the result is Ok, otherwise returns the Err value of self.
This function can be used for control flow based on Result values.
Basic usage:
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }
fn err(x: u32) -> Result<u32, u32> { Err(x) }
assert_eq!(Ok(2).and_then(sq).and_then(sq), Ok(16));
assert_eq!(Ok(2).and_then(sq).and_then(err), Err(4));
assert_eq!(Ok(2).and_then(err).and_then(sq), Err(2));
assert_eq!(Err(3).and_then(sq).and_then(sq), Err(3));Returns res if the result is Err, otherwise returns the Ok value of self.
Arguments passed to or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use or_else, which is lazily evaluated.
Basic usage:
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));
let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));
let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));Calls op if the result is Err, otherwise returns the Ok value of self.
This function can be used for control flow based on result values.
Basic usage:
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }
fn err(x: u32) -> Result<u32, u32> { Err(x) }
assert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));
assert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));
assert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));
assert_eq!(Err(3).or_else(err).or_else(err), Err(3));Returns the contained Ok value or a provided default.
Arguments passed to unwrap_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use unwrap_or_else, which is lazily evaluated.
Basic usage:
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);
let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);Returns the contained Ok value or computes it from a closure.
Basic usage:
fn count(x: &str) -> usize { x.len() }
assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);Returns the contained Ok value, consuming the self value, without checking that the value is not an Err.
Calling this method on an Err is undefined behavior.
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked(); } // Undefined behavior!Returns the contained Err value, consuming the self value, without checking that the value is not an Ok.
Calling this method on an Ok is undefined behavior.
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");🔬 This is a nightly-only experimental API. (option_result_contains #62358)
Returns true if the result is an Ok value containing the given value.
#![feature(option_result_contains)]
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.contains(&2), true);
let x: Result<u32, &str> = Ok(3);
assert_eq!(x.contains(&2), false);
let x: Result<u32, &str> = Err("Some error message");
assert_eq!(x.contains(&2), false);🔬 This is a nightly-only experimental API. (result_contains_err #62358)
Returns true if the result is an Err value containing the given value.
#![feature(result_contains_err)]
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.contains_err(&"Some error message"), false);
let x: Result<u32, &str> = Err("Some error message");
assert_eq!(x.contains_err(&"Some error message"), true);
let x: Result<u32, &str> = Err("Some other error message");
assert_eq!(x.contains_err(&"Some error message"), false);Maps a Result<&T, E> to a Result<T, E> by copying the contents of theOk part.
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));Maps a Result<&T, E> to a Result<T, E> by cloning the contents of theOk part.
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));Maps a Result<&mut T, E> to a Result<T, E> by copying the contents of theOk part.
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));Maps a Result<&mut T, E> to a Result<T, E> by cloning the contents of theOk part.
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));Transposes a Result of an Option into an Option of a Result.
Ok(None) will be mapped to None.Ok(Some(_)) and Err(_) will be mapped to Some(Ok(_)) and Some(Err(_)).
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;
let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);🔬 This is a nightly-only experimental API. (result_flattening #70142)
Converts from Result<Result<T, E>, E> to Result<T, E>
Basic usage:
#![feature(result_flattening)]
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());
let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());
let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());Flattening only removes one level of nesting at a time:
#![feature(result_flattening)]
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());🔬 This is a nightly-only experimental API. (result_into_ok_or_err #82223)
Returns the Ok value if self is Ok, and the Err value ifself is Err.
In other words, this function returns the value (the T) of aResult<T, T>, regardless of whether or not that result is Ok orErr.
This can be useful in conjunction with APIs such asAtomic*::compare_exchange, or slice::binary_search, but only in cases where you don’t care if the result was Ok or not.
#![feature(result_into_ok_or_err)]
let ok: Result<u32, u32> = Ok(3);
let err: Result<u32, u32> = Err(4);
assert_eq!(ok.into_ok_or_err(), 3);
assert_eq!(err.into_ok_or_err(), 4);Formats the value using the given formatter. Read more
Takes each element in the Iterator: if it is an Err, no further elements are taken, and the Err is returned. Should no Err occur, a container with the values of each Result is returned.
Here is an example which increments every integer in a vector, checking for overflow:
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));Here is another example that tries to subtract one from another list of integers, this time checking for underflow:
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));Here is a variation on the previous example, showing that no further elements are taken from iter after the first Err.
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
shared += x;
x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);Since the third element caused an underflow, no further elements were taken, so the final value of shared is 6 (= 3 + 2 + 1), not 16.
🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)
Constructs the type from a compatible Residual type. Read more
🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)
Constructs the type from a compatible Residual type. Read more
🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)
Constructs the type from a compatible Residual type. Read more
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
Creates an iterator from a value. Read more
Returns a consuming iterator over the possibly contained value.
The iterator yields one value if the result is Result::Ok, otherwise none.
Basic usage:
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);
let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);The type of the elements being iterated over.
Which kind of iterator are we turning this into?
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
Creates an iterator from a value. Read more
Compares and returns the maximum of two values. Read more
Compares and returns the minimum of two values. Read more
Restrict a value to a certain interval. Read more
This method tests for self and other values to be equal, and is used by ==. Read more
This method tests for !=.
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
This method tests greater than or equal to (for self and other) and is used by the >=operator. Read more
Takes each element in the Iterator: if it is an Err, no further elements are taken, and the Err is returned. Should no Erroccur, the product of all elements is returned.
🔬 This is a nightly-only experimental API. (try_trait_v2_residual #91285)
The “return” type of this meta-function.
Takes each element in the Iterator: if it is an Err, no further elements are taken, and the Err is returned. Should no Erroccur, the sum of all elements is returned.
This sums up every integer in a vector, rejecting the sum if a negative element is encountered:
let v = vec![1, 2];
let res: Result<i32, &'static str> = v.iter().map(|&x: &i32|
if x < 0 { Err("Negative element found") }
else { Ok(x) }
).sum();
assert_eq!(res, Ok(3));🔬 This is a nightly-only experimental API. (termination_trait_lib #43301)
Is called to get the representation of the value as status code. This status code is returned to the operating system. Read more
🔬 This is a nightly-only experimental API. (termination_trait_lib #43301)
Is called to get the representation of the value as status code. This status code is returned to the operating system. Read more
🔬 This is a nightly-only experimental API. (termination_trait_lib #43301)
Is called to get the representation of the value as status code. This status code is returned to the operating system. Read more
🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)
The type of the value produced by ? when not short-circuiting.
🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)
🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)
Constructs the type from its Output type. Read more
🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)
Used in ? 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 Any for T where
T: 'static + ?Sized,
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
impl From for T
impl<T, U> Into for T where
U: From,
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
🔬 This is a nightly-only experimental API. (toowned_clone_into #41263)
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.