impl<S:serialize::Encoder<E>, E> def_id_encoder_helpers for S {
fn emit_def_id(&mut self, did: ast::DefId) {
- did.encode(self).unwrap()
+ did.encode(self).ok().unwrap()
}
}
impl<D:serialize::Decoder<E>, E> def_id_decoder_helpers for D {
fn read_def_id(&mut self, xcx: &ExtendedDecodeContext) -> ast::DefId {
- let did: ast::DefId = Decodable::decode(self).unwrap();
+ let did: ast::DefId = Decodable::decode(self).ok().unwrap();
did.tr(xcx)
}
fn read_def_id_noxcx(&mut self,
cdata: @cstore::crate_metadata) -> ast::DefId {
- let did: ast::DefId = Decodable::decode(self).unwrap();
+ let did: ast::DefId = Decodable::decode(self).ok().unwrap();
decoder::translate_def_id(cdata, did)
}
}
use clone::Clone;
use cmp::Eq;
+use std::fmt::Show;
use iter::{Iterator, FromIterator};
use option::{None, Option, Some};
}
}
- /////////////////////////////////////////////////////////////////////////
- // Common special cases
- /////////////////////////////////////////////////////////////////////////
-
/// Unwraps a result, yielding the content of an `Ok`.
- /// Fails if the value is an `Err`.
+ /// Else it returns `optb`.
#[inline]
- pub fn unwrap(self) -> T {
+ pub fn unwrap_or(self, optb: T) -> T {
match self {
Ok(t) => t,
- Err(_) => fail!("called `Result::unwrap()` on an `Err` value")
+ Err(_) => optb
}
}
/// Unwraps a result, yielding the content of an `Ok`.
- /// Else it returns `optb`.
+ /// If the value is an `Err` then it calls `op` with its value.
#[inline]
- pub fn unwrap_or(self, optb: T) -> T {
+ pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
match self {
Ok(t) => t,
- Err(_) => optb
+ Err(e) => op(e)
}
}
+}
+impl<T, E: Show> Result<T, E> {
/// Unwraps a result, yielding the content of an `Ok`.
- /// If the value is an `Err` then it calls `op` with its value.
+ ///
+ /// Fails if the value is an `Err`.
#[inline]
- pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
+ pub fn unwrap(self) -> T {
match self {
Ok(t) => t,
- Err(e) => op(e)
+ Err(e) =>
+ fail!("called `Result::unwrap()` on an `Err` value: {}", e)
}
}
+}
+impl<T: Show, E> Result<T, E> {
/// Unwraps a result, yielding the content of an `Err`.
+ ///
/// Fails if the value is an `Ok`.
#[inline]
pub fn unwrap_err(self) -> E {
match self {
- Ok(_) => fail!("called `Result::unwrap_err()` on an `Ok` value"),
+ Ok(t) =>
+ fail!("called `Result::unwrap_err()` on an `Ok` value: {}", t),
Err(e) => e
}
}
None => return Err(~"TERM environment variable undefined")
};
- let entry = open(term);
- if entry.is_err() {
- if "cygwin" == term { // msys terminal
- return Ok(Terminal {out: out, ti: msys_terminfo(), num_colors: 8});
+ let mut file = match open(term) {
+ Ok(file) => file,
+ Err(err) => {
+ if "cygwin" == term { // msys terminal
+ return Ok(Terminal {
+ out: out,
+ ti: msys_terminfo(),
+ num_colors: 8
+ });
+ }
+ return Err(err);
}
- return Err(entry.unwrap_err());
- }
+ };
- let mut file = entry.unwrap();
- let ti = parse(&mut file, false);
- if ti.is_err() {
- return Err(ti.unwrap_err());
- }
+ let inf = try!(parse(&mut file, false));
- let inf = ti.unwrap();
let nc = if inf.strings.find_equiv(&("setaf")).is_some()
&& inf.strings.find_equiv(&("setab")).is_some() {
inf.numbers.find_equiv(&("colors")).map_or(0, |&n| n)