Struct std::result::Result

Either a success value or an error value.

See module level documentation for more information.

Example

let ok: Result<i32, i32> = Result::ok(1);
let err: Result<i32, i32> = Result::err(-1);

assert!(ok.is_ok());
assert!(err.is_err());

assert_eq!(ok.unwrap(), 1);
assert_eq!(err.unwrap_err(), -1);
Run this example

Methods

• fn ok(ok: T) -> Result<T, E>

  source

  Create a success variant

  Example

  let r: Result<i32, i32> = Result::ok(10);
  
  assert!(r.is_ok());
  assert_eq!(r.unwrap(), 10);
  Run this example

• fn err(err: E) -> Result<T, E>

  source

  Create a error variant

  Example

  let r: Result<i32, i32> = Result::err(42);
  
  assert!(r.is_err());
  assert_eq!(r.unwrap_err(), 42);
  Run this example

• fn is_ok(self: &Result<T, E>) -> bool

  source

  Returns true if the result conains an OK variant, false otherwise

• fn is_err(self: &Result<T, E>) -> bool

  source

  Returns true if the result conains an error variant, false otherwise

• fn get(self: Result<T, E>) -> Option<T>

  source

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

  If the result contains an error, it returns Option::none().

  Example

  let r1: Result<i32, i32> = Result::ok(10);
  let r2: Result<i32, i32> = Result::err(20);
  
  let o1: Option<i32> = r1.get();
  let o2: Option<i32> = r2.get();
  
  assert!(o1.is_some());
  assert_eq!(o1.unwrap(), 10);
  
  assert!(o2.is_none());
  Run this example

• fn get_err(self: Result<T, E>) -> Option<E>

  source

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

  If the result contains an OK varianr, it returns Option::none().

  Example

  let r1: Result<i32, i32> = Result::ok(10);
  let r2: Result<i32, i32> = Result::err(20);
  
  let o1: Option<i32> = r1.get_err();
  let o2: Option<i32> = r2.get_err();
  
  assert!(o1.is_none());
  
  assert!(o2.is_some());
  assert_eq!(o2.unwrap(), 20);
  Run this example

• fn unwrap(self: Result<T, E>) -> T

  source

  Return the success value, panicking if error value is present

  Examples

  let r: Result<i32, i32> = Result::ok(10);
  
  assert_eq!(r.unwrap(), 10);
  Run this example

  let r: Result<i32, i32> = Result::err(42);
  
  r.unwrap(); // panics
  Run this example

• fn unwrap_err(self: Result<T, E>) -> E

  source

  Return the error value, panicking if success value is present

  Examples

  let r: Result<i32, i32> = Result::err(10);
  
  assert_eq!(r.unwrap_err(), 10);
  Run this example

  let r: Result<i32, i32> = Result::ok(42);
  
  r.unwrap_err(); // panics
  Run this example

• fn unwrap_or(self: Result<T, E>, val: T) -> T

  source

  Return the success value or a default value

  Example

  let r1: Result<i32, i32> = Result::ok(10);
  let r2: Result<i32, i32> = Result::err(20);
  
  assert_eq!(r1.unwrap_or(30), 10);
  assert_eq!(r2.unwrap_or(40), 40);
  Run this example

• fn unwrap_or_else<F>(self: Result<T, E>, func: F) -> T

  F: Fn(E) -> T

  source

  Return the success value or a default value provided by a callback

  Example

  let r1: Result<i32, i32> = Result::ok(10);
  let r2: Result<i32, i32> = Result::err(20);
  
  assert_eq!(r1.unwrap_or_else(|_: i32| -> i32 { i32::max_value() }), 10);
  assert_eq!(r2.unwrap_or_else(|_: i32| -> i32 { i32::max_value() }), i32::max_value());
  Run this example

• fn map<Tm, F>(self: Result<T, E>, func: F) -> Result<Tm, E>

  F: Fn(T) -> Tm

  source

  Transform the success value inside the Result by calling the provided function.

  If the error value is present, function is not called and the original error is passed through.

  Example

  let a: Result<i32, ()> = Result::ok(42);
  let b: Result<i32, ()> = Result::err(());
  
  assert_eq!(a.map(|v: i32| -> i32 { v + 1 }), Result::ok(43));
  assert_eq!(b.map(|v: i32| -> i32 { v + 1 }), Result::err(()));
  Run this example

• fn map_err<Em, F>(self: Result<T, E>, func: F) -> Result<T, Em>

  F: Fn(E) -> Em

  source

  Transform the error value inside the Result by calling the provided function.

  If the success value is present, function is not called and the original error is passed through.

  Example

  let a: Result<(), i32> = Result::err(42);
  let b: Result<(), i32> = Result::ok(());
  
  assert_eq!(a.map_err(|v: i32| -> i32 { v + 1 }), Result::err(43));
  assert_eq!(b.map_err(|v: i32| -> i32 { v + 1 }), Result::ok(()));
  Run this example

• fn and_then<Tm, F>(self: Result<T, E>, func: F) -> Result<Tm, E>

  F: Fn(T) -> Result<Tm, E>

  source

  Transform the value inside the Result by calling the provided function, which returns a Result.

  If the success value is present, function is not called and the original error is passed through.

• fn transpose<T, E>(self: Result<Option<T>, E>) -> Option<Result<T, E>>

  source

  Convert Result<Option<T>, E> to Option<Result<T, E>>

  See also transpose for the reverse operation.

  Example

  let a: Result<Option<i32>, i32> = Result::ok(Option::some(42));
  let b: Result<Option<i32>, i32> = Result::ok(Option::none());
  let c: Result<Option<i32>, i32> = Result::err(1337);
  
  assert_eq!(a.transpose(), Option::some(Result::ok(42)));
  assert_eq!(b.transpose(), Option::none());
  assert_eq!(c.transpose(), Option::some(Result::err(1337)));
  Run this example

• fn fmt<T, E, F>(self: &Result<T, E>, formatter: &mut F) -> Result

  T: Formattable<T, F>

  E: Formattable<E, F>

  F: Formatter<F>

  source

  Write the object into a given formatter.

  See Formattable for details.

• fn hash<T, E, H>(self: &Result<T, E>, hasher: &mut H)

  T: Hashable<T, H>

  E: Hashable<E, H>

  H: Hasher<H>

  source

  Update hasher state with the contents of this object.

  See Hashable for details.

• fn equals<T, E>(lhs: &Result<T, E>, rhs: &Result<T, E>) -> bool

  T: Equatable<T>

  E: Equatable<E>

  source

  Returns true if arguments are equal, false otherwise

  See Equatable for details.

• fn move<T, E>(self: &mut Result<T, E>) -> Result<T, E>

  T: Movable<T>

  E: Movable<E>

  source

  Creates a copy of the object, leaving an inert object behind.

  See Movable for details.

• fn free<T, E>(self: &mut Result<T, E>)

  T: Freeable<T>

  E: Freeable<E>

  source

  Frees the memory backing the object.

Mixins

• mixin<T, E> Equatable<Result<T, E>>

  T: Equatable<T>

  E: Equatable<E>

• fn not_equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns false if arguments are equal, true otherwise