Prevent duplicated error information in "wrapping errors" example

The "Wrapping errors" example, which illustrates how to wrap errors, is
using the wrapped error in the text that is displayed as well as the
implementation of source(). In so doing it effectively duplicates the
error information. Such behavior does not play nice with error reporting
crates such as anyhow, eyre, and others that make use of both this data.
It is also questionable at best from a logical point of view, because,
as the name suggests, the source should be a lower level error that is
the cause of this one.
With this change we update the documentation, suggesting the usage of a
custom error string describing at a higher level what went wrong. To
keep the example simple, we did not include the actual string in the
error (a comment already suggests that this could be done), although
that probably should be done in real life to provide additional context.
An alternative approach would be to not return a source, but I figured
that it's sort of desired for the illustration of wrapping an error.

Author: d-e-s-o

src/error/multiple_error_types/wrap_error.md

@@ -4,6 +4,7 @@ An alternative to boxing errors is to wrap them in your own error type.
 
 ```rust,editable
 use std::error;
+use std::error::Error as _;
 use std::num::ParseIntError;
 use std::fmt;
 
@@ -22,8 +23,10 @@ impl fmt::Display for DoubleError {
         match *self {
             DoubleError::EmptyVec =>
                 write!(f, "please use a vector with at least one element"),
-            // This is a wrapper, so defer to the underlying types' implementation of `fmt`.
-            DoubleError::Parse(ref e) => e.fmt(f),
+            // The wrapped error contains additional information and is available
+            // via the source() method.
+            DoubleError::Parse(..) =>
+                write!(f, "the provided string could not be parsed as int"),
         }
     }
 }
@@ -51,6 +54,8 @@ impl From<ParseIntError> for DoubleError {
 
 fn double_first(vec: Vec<&str>) -> Result<i32> {
     let first = vec.first().ok_or(DoubleError::EmptyVec)?;
+    // Here we implicitly use the `ParseIntError` implementation of `From` (which
+    // we defined above) in order to create a `DoubleError`.
     let parsed = first.parse::<i32>()?;
 
     Ok(2 * parsed)
@@ -59,7 +64,12 @@ fn double_first(vec: Vec<&str>) -> Result<i32> {
 fn print(result: Result<i32>) {
     match result {
         Ok(n)  => println!("The first doubled is {}", n),
-        Err(e) => println!("Error: {}", e),
+        Err(e) => {
+            println!("Error: {}", e);
+            if let Some(source) = e.source() {
+                println!("  Caused by: {}", source);
+            }
+        },
     }
 }