std::io::Result
[−]
[src]
type Result<T> = Result<T, Error>;
A type for results generated by I/O related functions where the Err type
is hard-wired to io::Error.
This typedef is generally used to avoid writing out io::Error directly and
is otherwise a direct mapping to std::result::Result.
Methods
impl<T, E> Result<T, E>
fn is_ok(&self) -> bool
Returns true if the result is Ok
Examples
fn main() { 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); }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);
fn is_err(&self) -> bool
Returns true if the result is Err
Examples
fn main() { 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); }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);
fn ok(self) -> Option<T>
Converts from Result<T, E> to Option<T>
Converts self into an Option<T>, consuming self,
and discarding the error, if any.
Examples
fn main() { 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); }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);
fn err(self) -> Option<E>
Converts from Result<T, E> to Option<E>
Converts self into an Option<E>, consuming self,
and discarding the success value, if any.
Examples
fn main() { 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")); }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"));
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.
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"));
fn as_mut(&mut self) -> Result<&mut T, &mut E>
Converts from Result<T, E> to Result<&mut T, &mut E>
fn mutate(r: &mut Result<i32, i32>) { match r.as_mut() { Ok(&mut ref mut v) => *v = 42, Err(&mut ref mut 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);
fn as_slice(&self) -> &[T]
Unstable
Converts from Result<T, E> to &[T] (without copying)
fn as_mut_slice(&mut self) -> &mut [T]
Unstable
: waiting for mut conventions
Converts from Result<T, E> to &mut [T] (without copying)
let mut x: Result<&str, u32> = Ok("Gold"); { let v = x.as_mut_slice(); assert!(v == ["Gold"]); v[0] = "Silver"; assert!(v == ["Silver"]); } assert_eq!(x, Ok("Silver")); let mut x: Result<&str, u32> = Err(45); assert!(x.as_mut_slice().is_empty());
fn map<U, F>(self, op: F) -> Result<U, E> where F: FnOnce(T) -> U
Maps a Result<T, E> to Result<U, E> by applying a function to an
contained Ok value, leaving an Err value untouched.
This function can be used to compose the results of two functions.
Examples
Print the numbers on each line of a string multiplied by two.
fn main() { 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(..) => {} } } }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(..) => {} } }
fn map_err<F, O>(self, op: O) -> Result<T, F> where O: FnOnce(E) -> F
Maps a Result<T, E> to Result<T, F> by applying a function to an
contained Err value, leaving an Ok value untouched.
This function can be used to pass through a successful result while handling an error.
Examples
fn main() { 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())); }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()));
fn iter(&self) -> Iter<T>
Returns an iterator over the possibly contained value.
Examples
fn main() { 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); }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);
fn iter_mut(&mut self) -> IterMut<T>
Returns a mutable iterator over the possibly contained value.
Examples
fn main() { let mut x: Result<u32, &str> = Ok(7); match x.iter_mut().next() { Some(&mut ref mut x) => *x = 40, None => {}, } assert_eq!(x, Ok(40)); let mut x: Result<u32, &str> = Err("nothing!"); assert_eq!(x.iter_mut().next(), None); }let mut x: Result<u32, &str> = Ok(7); match x.iter_mut().next() { Some(&mut ref mut x) => *x = 40, None => {}, } assert_eq!(x, Ok(40)); let mut x: Result<u32, &str> = Err("nothing!"); assert_eq!(x.iter_mut().next(), None);
fn and<U>(self, res: Result<U, E>) -> Result<U, E>
Returns res if the result is Ok, otherwise returns the Err value of self.
Examples
fn main() { 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")); }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"));
fn and_then<U, F>(self, op: F) -> Result<U, E> where F: FnOnce(T) -> Result<U, E>
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.
Examples
fn main() { 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)); }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));
fn or<F>(self, res: Result<T, F>) -> Result<T, F>
Returns res if the result is Err, otherwise returns the Ok value of self.
Examples
fn main() { 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)); }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));
fn or_else<F, O>(self, op: O) -> Result<T, F> where O: FnOnce(E) -> Result<T, F>
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.
Examples
fn main() { 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)); }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));
fn unwrap_or(self, optb: T) -> T
Unwraps a result, yielding the content of an Ok.
Else it returns optb.
Examples
fn main() { let optb = 2; let x: Result<u32, &str> = Ok(9); assert_eq!(x.unwrap_or(optb), 9); let x: Result<u32, &str> = Err("error"); assert_eq!(x.unwrap_or(optb), optb); }let optb = 2; let x: Result<u32, &str> = Ok(9); assert_eq!(x.unwrap_or(optb), 9); let x: Result<u32, &str> = Err("error"); assert_eq!(x.unwrap_or(optb), optb);
fn unwrap_or_else<F>(self, op: F) -> T where F: FnOnce(E) -> T
Unwraps a result, yielding the content of an Ok.
If the value is an Err then it calls op with its value.
Examples
fn main() { 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); }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);
impl<T, E> Result<T, E> where E: Debug
fn unwrap(self) -> T
Unwraps a result, yielding the content of an Ok.
Panics
Panics if the value is an Err, with a panic message provided by the
Err's value.
Examples
fn main() { let x: Result<u32, &str> = Ok(2); assert_eq!(x.unwrap(), 2); }let x: Result<u32, &str> = Ok(2); assert_eq!(x.unwrap(), 2);fn main() { let x: Result<u32, &str> = Err("emergency failure"); x.unwrap(); // panics with `emergency failure` }
let x: Result<u32, &str> = Err("emergency failure"); x.unwrap(); // panics with `emergency failure`
impl<T, E> Result<T, E> where T: Debug
fn unwrap_err(self) -> E
Unwraps a result, yielding the content of an Err.
Panics
Panics if the value is an Ok, with a custom panic message provided
by the Ok's value.
Examples
fn main() { let x: Result<u32, &str> = Ok(2); x.unwrap_err(); // panics with `2` }let x: Result<u32, &str> = Ok(2); x.unwrap_err(); // panics with `2`fn main() { let x: Result<u32, &str> = Err("emergency failure"); assert_eq!(x.unwrap_err(), "emergency failure"); }
let x: Result<u32, &str> = Err("emergency failure"); assert_eq!(x.unwrap_err(), "emergency failure");