Backport copyedit changes to ch15

Author: carols10cents

listings/ch15-smart-pointers/listing-15-14/output.txt

@@ -2,6 +2,6 @@ $ cargo run
    Compiling drop-example v0.1.0 (file:///projects/drop-example)
     Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.60s
      Running `target/debug/drop-example`
-CustomSmartPointers created.
+CustomSmartPointers created
 Dropping CustomSmartPointer with data `other stuff`!
 Dropping CustomSmartPointer with data `my stuff`!

listings/ch15-smart-pointers/listing-15-14/src/main.rs

@@ -15,5 +15,5 @@ fn main() {
     let d = CustomSmartPointer {
         data: String::from("other stuff"),
     };
-    println!("CustomSmartPointers created.");
+    println!("CustomSmartPointers created");
 }

listings/ch15-smart-pointers/listing-15-15/src/main.rs

@@ -13,8 +13,8 @@ fn main() {
     let c = CustomSmartPointer {
         data: String::from("some data"),
     };
-    println!("CustomSmartPointer created.");
+    println!("CustomSmartPointer created");
     c.drop();
-    println!("CustomSmartPointer dropped before the end of main.");
+    println!("CustomSmartPointer dropped before the end of main");
 }
 // ANCHOR_END: here

listings/ch15-smart-pointers/listing-15-16/output.txt

@@ -2,6 +2,6 @@ $ cargo run
    Compiling drop-example v0.1.0 (file:///projects/drop-example)
     Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.73s
      Running `target/debug/drop-example`
-CustomSmartPointer created.
+CustomSmartPointer created
 Dropping CustomSmartPointer with data `some data`!
-CustomSmartPointer dropped before the end of main.
+CustomSmartPointer dropped before the end of main

listings/ch15-smart-pointers/listing-15-16/src/main.rs

@@ -13,8 +13,8 @@ fn main() {
     let c = CustomSmartPointer {
         data: String::from("some data"),
     };
-    println!("CustomSmartPointer created.");
+    println!("CustomSmartPointer created");
     drop(c);
-    println!("CustomSmartPointer dropped before the end of main.");
+    println!("CustomSmartPointer dropped before the end of main");
 }
 // ANCHOR_END: here

listings/ch15-smart-pointers/listing-15-25/src/main.rs

@@ -1,3 +1,4 @@
+// ANCHOR: here
 use crate::List::{Cons, Nil};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -16,5 +17,6 @@ impl List {
         }
     }
 }
+// ANCHOR_END: here
 
 fn main() {}

nostarch/chapter15.md

@@ -1,6 +1,6 @@
 # Smart Pointers
 
-A _pointer_ is a general concept for a variable that contains an address in
+A pointer is a general concept for a variable that contains an address in
 memory. This address refers to, or “points at,” some other data. The most
 common kind of pointer in Rust is a reference, which you learned about in
 Chapter 4. References are indicated by the `&` symbol and borrow the value they
@@ -9,25 +9,25 @@ data, and they have no overhead.
 
 _Smart pointers_, on the other hand, are data structures that act like a
 pointer but also have additional metadata and capabilities. The concept of
-smart pointers isn’t unique to Rust: smart pointers originated in C++ and exist
+smart pointers isn’t unique to Rust: Smart pointers originated in C++ and exist
 in other languages as well. Rust has a variety of smart pointers defined in the
 standard library that provide functionality beyond that provided by references.
 To explore the general concept, we’ll look at a couple of different examples of
 smart pointers, including a _reference counting_ smart pointer type. This
 pointer enables you to allow data to have multiple owners by keeping track of
 the number of owners and, when no owners remain, cleaning up the data.
 
-Rust, with its concept of ownership and borrowing, has an additional difference
-between references and smart pointers: while references only borrow data, in
-many cases smart pointers _own_ the data they point to.
+In Rust, with its concept of ownership and borrowing, there is an additional
+difference between references and smart pointers: While references only borrow
+data, in many cases smart pointers _own_ the data they point to.
 
 Smart pointers are usually implemented using structs. Unlike an ordinary
 struct, smart pointers implement the `Deref` and `Drop` traits. The `Deref`
 trait allows an instance of the smart pointer struct to behave like a reference
-so you can write your code to work with either references or smart pointers.
-The `Drop` trait allows you to customize the code that’s run when an instance
-of the smart pointer goes out of scope. In this chapter, we’ll discuss both of
-these traits and demonstrate why they’re important to smart pointers.
+so that you can write your code to work with either references or smart
+pointers. The `Drop` trait allows you to customize the code that’s run when an
+instance of the smart pointer goes out of scope. In this chapter, we’ll discuss
+both of these traits and demonstrate why they’re important to smart pointers.
 
 Given that the smart pointer pattern is a general design pattern used
 frequently in Rust, this chapter won’t cover every existing smart pointer. Many

nostarch/docx/chapter15.docx

@@ -9,11 +9,11 @@ Boxes don’t have performance overhead, other than storing their data on the
 heap instead of on the stack. But they don’t have many extra capabilities
 either. You’ll use them most often in these situations:
 
-- When you have a type whose size can’t be known at compile time and you want
+- When you have a type whose size can’t be known at compile time, and you want
   to use a value of that type in a context that requires an exact size
-- When you have a large amount of data and you want to transfer ownership but
-  ensure the data won’t be copied when you do so
-- When you want to own a value and you care only that it’s a type that
+- When you have a large amount of data, and you want to transfer ownership but
+  ensure that the data won’t be copied when you do so
+- When you want to own a value, and you care only that it’s a type that
   implements a particular trait rather than being of a specific type
 
 We’ll demonstrate the first situation in [“Enabling Recursive Types with
@@ -23,9 +23,9 @@ because the data is copied around on the stack. To improve performance in this
 situation, we can store the large amount of data on the heap in a box. Then,
 only the small amount of pointer data is copied around on the stack, while the
 data it references stays in one place on the heap. The third case is known as a
-_trait object_, and [“Using Trait Objects That Allow for Values of Different
-Types,”][trait-objects]<!-- ignore --> in Chapter 18 is devoted to that topic.
-So what you learn here you’ll apply again in that section!
+_trait object_, and [“Using Trait Objects to Abstract over Shared
+Behavior”][trait-objects]<!-- ignore --> in Chapter 18 is devoted to that
+topic. So, what you learn here you’ll apply again in that section!
 
 <!-- Old headings. Do not remove or links may break. -->
 
@@ -69,10 +69,10 @@ types could theoretically continue infinitely, so Rust can’t know how much spa
 the value needs. Because boxes have a known size, we can enable recursive types
 by inserting a box in the recursive type definition.
 
-As an example of a recursive type, let’s explore the _cons list_. This is a data
+As an example of a recursive type, let’s explore the cons list. This is a data
 type commonly found in functional programming languages. The cons list type
 we’ll define is straightforward except for the recursion; therefore, the
-concepts in the example we’ll work with will be useful any time you get into
+concepts in the example we’ll work with will be useful anytime you get into
 more complex situations involving recursive types.
 
 <!-- Old headings. Do not remove or links may break. -->
@@ -96,11 +96,11 @@ list `1, 2, 3` with each pair in parentheses:
 ```
 
 Each item in a cons list contains two elements: the value of the current item
-and the next item. The last item in the list contains only a value called `Nil`
-without a next item. A cons list is produced by recursively calling the `cons`
-function. The canonical name to denote the base case of the recursion is `Nil`.
-Note that this is not the same as the “null” or “nil” concept discussed in
-Chapter 6, which is an invalid or absent value.
+and of the next item. The last item in the list contains only a value called
+`Nil` without a next item. A cons list is produced by recursively calling the
+`cons` function. The canonical name to denote the base case of the recursion is
+`Nil`. Note that this is not the same as the “null” or “nil” concept discussed
+in Chapter 6, which is an invalid or absent value.
 
 The cons list isn’t a commonly used data structure in Rust. Most of the time
 when you have a list of items in Rust, `Vec<T>` is a better choice to use.
@@ -109,7 +109,7 @@ but by starting with the cons list in this chapter, we can explore how boxes
 let us define a recursive data type without much distraction.
 
 Listing 15-2 contains an enum definition for a cons list. Note that this code
-won’t compile yet because the `List` type doesn’t have a known size, which
+won’t compile yet, because the `List` type doesn’t have a known size, which
 we’ll demonstrate.
 
 <Listing number="15-2" file-name="src/main.rs" caption="The first attempt at defining an enum to represent a cons list data structure of `i32` values">
@@ -153,9 +153,9 @@ Listing 15-4.
 </Listing>
 
 The error shows this type “has infinite size.” The reason is that we’ve defined
-`List` with a variant that is recursive: it holds another value of itself
+`List` with a variant that is recursive: It holds another value of itself
 directly. As a result, Rust can’t figure out how much space it needs to store a
-`List` value. Let’s break down why we get this error. First we’ll look at how
+`List` value. Let’s break down why we get this error. First, we’ll look at how
 Rust decides how much space it needs to store a value of a non-recursive type.
 
 #### Computing the Size of a Non-Recursive Type
@@ -183,7 +183,7 @@ type needs, the compiler looks at the variants, starting with the `Cons`
 variant. The `Cons` variant holds a value of type `i32` and a value of type
 `List`, and this process continues infinitely, as shown in Figure 15-1.
 
-<img alt="An infinite Cons list: a rectangle labeled 'Cons' split into two smaller rectangles. The first smaller rectangle holds the label 'i32', and the second smaller rectangle holds the label 'Cons' and a smaller version of the outer 'Cons' rectangle. The 'Cons' rectangles continue to hold smaller and smaller versions of themselves until the smallest comfortably-sized rectangle holds an infinity symbol, indicating that this repetition goes on forever" src="img/trpl15-01.svg" class="center" style="width: 50%;" />
+<img alt="An infinite Cons list: a rectangle labeled 'Cons' split into two smaller rectangles. The first smaller rectangle holds the label 'i32', an d the second smaller rectangle holds the label 'Cons' and a smaller version of the outer 'Cons' rectangle. The 'Cons' rectangles continue to hold sm aller and smaller versions of themselves until the smallest comfortably sized rectangle holds an infinity symbol, indicating that this repetition goes on forever." src="img/trpl15-01.svg" class="center" style="width: 50%;" />
 
 <span class="caption">Figure 15-1: An infinite `List` consisting of infinite
 `Cons` variants</span>
@@ -213,7 +213,7 @@ directly, we should change the data structure to store the value indirectly by
 storing a pointer to the value instead.
 
 Because a `Box<T>` is a pointer, Rust always knows how much space a `Box<T>`
-needs: a pointer’s size doesn’t change based on the amount of data it’s
+needs: A pointer’s size doesn’t change based on the amount of data it’s
 pointing to. This means we can put a `Box<T>` inside the `Cons` variant instead
 of another `List` value directly. The `Box<T>` will point to the next `List`
 value that will be on the heap rather than inside the `Cons` variant.
@@ -224,25 +224,25 @@ rather than inside one another.
 We can change the definition of the `List` enum in Listing 15-2 and the usage
 of the `List` in Listing 15-3 to the code in Listing 15-5, which will compile.
 
-<Listing number="15-5" file-name="src/main.rs" caption="Definition of `List` that uses `Box<T>` in order to have a known size">
+<Listing number="15-5" file-name="src/main.rs" caption="The definition of `List` that uses `Box<T>` in order to have a known size">
 
 ```rust
 {{#rustdoc_include ../listings/ch15-smart-pointers/listing-15-05/src/main.rs}}
 ```
 
 </Listing>
 
-The `Cons` variant needs the size of an `i32` plus the space to store the
-box’s pointer data. The `Nil` variant stores no values, so it needs less space
-on the stack than the `Cons` variant. We now know that any `List` value will
-take up the size of an `i32` plus the size of a box’s pointer data. By using a
-box, we’ve broken the infinite, recursive chain, so the compiler can figure out
-the size it needs to store a `List` value. Figure 15-2 shows what the `Cons`
+The `Cons` variant needs the size of an `i32` plus the space to store the box’s
+pointer data. The `Nil` variant stores no values, so it needs less space on the
+stack than the `Cons` variant. We now know that any `List` value will take up
+the size of an `i32` plus the size of a box’s pointer data. By using a box,
+we’ve broken the infinite, recursive chain, so the compiler can figure out the
+size it needs to store a `List` value. Figure 15-2 shows what the `Cons`
 variant looks like now.
 
-<img alt="A rectangle labeled 'Cons' split into two smaller rectangles. The first smaller rectangle holds the label 'i32', and the second smaller rectangle holds the label 'Box' with one inner rectangle that contains the label 'usize', representing the finite size of the box's pointer" src="img/trpl15-02.svg" class="center" />
+<img alt="A rectangle labeled 'Cons' split into two smaller rectangles. The first smaller rectangle holds the label 'i32', and the second smaller rectangle holds the label 'Box' with one inner rectangle that contains the label 'usize', representing the finite size of the box's pointer." src="img/trpl15-02.svg" class="center" />
 
-<span class="caption">Figure 15-2: A `List` that is not infinitely sized
+<span class="caption">Figure 15-2: A `List` that is not infinitely sized,
 because `Cons` holds a `Box`</span>
 
 Boxes provide only the indirection and heap allocation; they don’t have any
@@ -260,4 +260,4 @@ even more important to the functionality provided by the other smart pointer
 types we’ll discuss in the rest of this chapter. Let’s explore these two traits
 in more detail.
 
-[trait-objects]: ch18-02-trait-objects.html#using-trait-objects-that-allow-for-values-of-different-types
+[trait-objects]: ch18-02-trait-objects.html#using-trait-objects-to-abstract-over-shared-behavior