Rename ShowOnDrop -> PrintOnDrop

Author: matthewjasper

src/destructors.md

@@ -25,29 +25,29 @@ pointer, [`std::ptr::drop_in_place`] can be used.
 Some examples:
 
 ```rust
-struct ShowOnDrop(&'static str);
+struct PrintOnDrop(&'static str);
 
-impl Drop for ShowOnDrop {
+impl Drop for PrintOnDrop {
     fn drop(&mut self) {
         println!("{}", self.0);
     }
 }
 
-let mut overwritten = ShowOnDrop("drops when overwritten");
-overwritten = ShowOnDrop("drops when scope ends");
+let mut overwritten = PrintOnDrop("drops when overwritten");
+overwritten = PrintOnDrop("drops when scope ends");
 
-let tuple = (ShowOnDrop("Tuple first"), ShowOnDrop("Tuple second"));
+let tuple = (PrintOnDrop("Tuple first"), PrintOnDrop("Tuple second"));
 
 let moved;
 // No destructor run on assignment.
-moved = ShowOnDrop("Drops when moved");
+moved = PrintOnDrop("Drops when moved");
 // Drops now, but is then uninitialized.
 moved;
 
-let uninitialized: ShowOnDrop;
+let uninitialized: PrintOnDrop;
 // Only the first element is dropped.
-let mut partially_initialized: (ShowOnDrop, ShowOnDrop);
-partially_initialized.0 = ShowOnDrop("Partial tuple first");
+let mut partially_initialized: (PrintOnDrop, PrintOnDrop);
+partially_initialized.0 = PrintOnDrop("Partial tuple first");
 ```
 
 ## Drop scopes
@@ -97,22 +97,22 @@ dropped last when evaluating the function. Actual function parameters are
 dropped after any named parameters that are bound to parts of it.
 
 ```rust
-# struct ShowOnDrop(&'static str);
-# impl Drop for ShowOnDrop {
+# struct PrintOnDrop(&'static str);
+# impl Drop for PrintOnDrop {
 #     fn drop(&mut self) {
 #         println!("drop({})", self.0);
 #     }
 # }
 // Drops the second parameter, then `y`, then the first parameter, then `x`
 fn patterns_in_parameters(
-    (x, _): (ShowOnDrop, ShowOnDrop),
-    (_, y): (ShowOnDrop, ShowOnDrop),
+    (x, _): (PrintOnDrop, PrintOnDrop),
+    (_, y): (PrintOnDrop, PrintOnDrop),
 ) {}
 
 // drop order is 3 2 0 1
 patterns_in_parameters(
-    (ShowOnDrop("0"), ShowOnDrop("1")),
-    (ShowOnDrop("2"), ShowOnDrop("3")),
+    (PrintOnDrop("0"), PrintOnDrop("1")),
+    (PrintOnDrop("2"), PrintOnDrop("3")),
 );
 ```
 
@@ -124,17 +124,17 @@ the block that contains the `let` statement. Local variables declared in a
 in.
 
 ```rust
-# struct ShowOnDrop(&'static str);
-# impl Drop for ShowOnDrop {
+# struct PrintOnDrop(&'static str);
+# impl Drop for PrintOnDrop {
 #     fn drop(&mut self) {
 #         println!("drop({})", self.0);
 #     }
 # }
-let declared_first = ShowOnDrop("Dropped last in outer scope");
+let declared_first = PrintOnDrop("Dropped last in outer scope");
 {
-    let declared_in_block = ShowOnDrop("Dropped in inner scope");
+    let declared_in_block = PrintOnDrop("Dropped in inner scope");
 }
-let declared_last = ShowOnDrop("Dropped first in outer scope");
+let declared_last = PrintOnDrop("Dropped first in outer scope");
 ```
 
 If multiple patterns are used in the same arm for a `match` expression, then an unspecified
@@ -153,7 +153,8 @@ smallest scope that contains the expression and is for one of the following:
 * A statement.
 * The body of a [`if`], [`while`] or [`loop`] expression.
 * The `else` block of an `if` expression.
-* The condition expression of an `if` or `while` expression, or a `match` guard.
+* The condition expression of an `if` or `while` expression, or a `match`
+  guard.
 * The expression for a match arm.
 * The second operand of a [lazy boolean expression].
 
@@ -164,36 +165,36 @@ smallest scope that contains the expression and is for one of the following:
 Some examples:
 
 ```rust
-# struct ShowOnDrop(&'static str);
-# impl Drop for ShowOnDrop {
+# struct PrintOnDrop(&'static str);
+# impl Drop for PrintOnDrop {
 #     fn drop(&mut self) {
 #         println!("drop({})", self.0);
 #     }
 # }
-let local_var = ShowOnDrop("local var");
+let local_var = PrintOnDrop("local var");
 
 // Dropped once the condition has been evaluated
-if ShowOnDrop("If condition").0 == "If condition" {
+if PrintOnDrop("If condition").0 == "If condition" {
     // Dropped at the end of the block
-    ShowOnDrop("If body").0
+    PrintOnDrop("If body").0
 } else {
     unreachable!()
 };
 
 // Dropped at the end of the statement
-(ShowOnDrop("first operand").0 == ""
+(PrintOnDrop("first operand").0 == ""
 // Dropped at the )
-|| ShowOnDrop("second operand").0 == "")
+|| PrintOnDrop("second operand").0 == "")
 // Dropped at the end of the expression
-|| ShowOnDrop("third operand").0 == "";
+|| PrintOnDrop("third operand").0 == "";
 
 // Dropped at the end of the function, after local variables.
 // Changing this to a statement containing a return expression would make the
 // temporary be dropped before the local variables. Binding to a variable
 // which is then returned would also make the temporary be dropped first.
-match ShowOnDrop("Matched value in final expression") {
+match PrintOnDrop("Matched value in final expression") {
     // Dropped once the condition has been evaluated
-    _ if ShowOnDrop("guard condition").0 == "" => (),
+    _ if PrintOnDrop("guard condition").0 == "" => (),
     _ => (),
 }
 ```
@@ -207,23 +208,23 @@ once the expression is evaluated, dropping them has no effect unless one of the
 operands to an expression breaks out of the expression, returns, or panics.
 
 ```rust
-# struct ShowOnDrop(&'static str);
-# impl Drop for ShowOnDrop {
+# struct PrintOnDrop(&'static str);
+# impl Drop for PrintOnDrop {
 #     fn drop(&mut self) {
 #         println!("drop({})", self.0);
 #     }
 # }
 loop {
     // Tuple expression doesn't finish evaluating so operands drop in reverse order
     (
-        ShowOnDrop("Outer tuple first"),
-        ShowOnDrop("Outer tuple second"),
+        PrintOnDrop("Outer tuple first"),
+        PrintOnDrop("Outer tuple second"),
         (
-            ShowOnDrop("Inner tuple first"),
-            ShowOnDrop("Inner tuple second"),
+            PrintOnDrop("Inner tuple first"),
+            PrintOnDrop("Inner tuple second"),
             break,
         ),
-        ShowOnDrop("Never created"),
+        PrintOnDrop("Never created"),
     );
 }
 ```