Make Result::{unwrap, unwrap_err} require Show

`foo.ok().unwrap()` and `foo.err().unwrap()` are the fallbacks for types
that aren't `Show`.

Closes #13379

src/librustc/middle/astencode.rs

@@ -266,7 +266,7 @@ trait def_id_encoder_helpers {
 
 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()
     }
 }
 
@@ -278,13 +278,13 @@ trait def_id_decoder_helpers {
 
 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)
     }
 }

src/libstd/comm/mod.rs

@@ -496,7 +496,7 @@ impl<T: Send> Sender<T> {
                                 // This send cannot fail because the task is
                                 // asleep (we're looking at it), so the receiver
                                 // can't go away.
-                                (*a.get()).send(t).unwrap();
+                                (*a.get()).send(t).ok().unwrap();
                                 task.wake().map(|t| t.reawaken());
                                 (a, Ok(()))
                             }

src/libstd/result.rs

@@ -12,6 +12,7 @@
 
 use clone::Clone;
 use cmp::Eq;
+use std::fmt::Show;
 use iter::{Iterator, FromIterator};
 use option::{None, Option, Some};
 
@@ -174,46 +175,50 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
-    // 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
         }
     }

src/libterm/lib.rs

@@ -132,21 +132,22 @@ impl<T: Writer> Terminal<T> {
             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)