PR 2363's use of &T made Copy/Clone traits unnecessary in section 10.2

listings/ch10-generic-types-traits-and-lifetimes/no-listing-07-fixing-listing-10-05/output.txt

@@ -1,29 +1,6 @@
 $ cargo run
    Compiling chapter10 v0.1.0 (file:///projects/chapter10)
-error[E0508]: cannot move out of type `[T]`, a non-copy slice
- --> src/main.rs:2:23
-  |
-2 |     let mut largest = list[0];
-  |                       ^^^^^^^
-  |                       |
-  |                       cannot move out of here
-  |                       move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
-  |                       help: consider borrowing here: `&list[0]`
-
-error[E0507]: cannot move out of a shared reference
- --> src/main.rs:4:18
-  |
-4 |     for &item in list {
-  |         -----    ^^^^
-  |         ||
-  |         |data moved here
-  |         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
-  |         help: consider removing the `&`: `item`
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0507, E0508.
-For more information about an error, try `rustc --explain E0507`.
-error: could not compile `chapter10`
-
-To learn more, run the command again with --verbose.
+    Finished dev [unoptimized + debuginfo] target(s) in 0.52s
+     Running `target/debug/chapter10`
+The largest number is 100
+The largest char is y

listings/ch10-generic-types-traits-and-lifetimes/no-listing-07-fixing-listing-10-05/src/main.rs

@@ -1,9 +1,9 @@
 // ANCHOR: here
-fn largest<T: PartialOrd>(list: &[T]) -> T {
+fn largest<T: PartialOrd>(list: &[T]) -> &T {
     // ANCHOR_END: here
-    let mut largest = list[0];
+    let mut largest = &list[0];
 
-    for &item in list {
+    for item in list {
         if item > largest {
             largest = item;
         }

src/ch10-02-traits.md

@@ -358,52 +358,8 @@ look like this:
 {{#rustdoc_include ../listings/ch10-generic-types-traits-and-lifetimes/no-listing-07-fixing-listing-10-05/src/main.rs:here}}
 ```
 
-This time when we compile the code, we get a different set of errors:
-
-```console
-{{#include ../listings/ch10-generic-types-traits-and-lifetimes/no-listing-07-fixing-listing-10-05/output.txt}}
-```
-
-The key line in this error is `cannot move out of type [T], a non-copy slice`.
-With our non-generic versions of the `largest` function, we were only trying to
-find the largest `i32` or `char`. As discussed in the [“Stack-Only Data:
-Copy”][stack-only-data-copy]<!-- ignore --> section in Chapter 4, types like
-`i32` and `char` that have a known size can be stored on the stack, so they
-implement the `Copy` trait. But when we made the `largest` function generic,
-it became possible for the `list` parameter to have types in it that don’t
-implement the `Copy` trait. Consequently, we wouldn’t be able to move the
-value out of `list[0]` and into the `largest` variable, resulting in this
-error.
-
-To call this code with only those types that implement the `Copy` trait, we can
-add `Copy` to the trait bounds of `T`! Listing 10-15 shows the complete code of
-a generic `largest` function that will compile as long as the types of the
-values in the slice that we pass into the function implement the `PartialOrd`
-*and* `Copy` traits, like `i32` and `char` do.
-
-<span class="filename">Filename: src/main.rs</span>
-
-```rust
-{{#rustdoc_include ../listings/ch10-generic-types-traits-and-lifetimes/listing-10-15/src/main.rs}}
-```
-
-<span class="caption">Listing 10-15: A working definition of the `largest`
-function that works on any generic type that implements the `PartialOrd` and
-`Copy` traits</span>
-
-If we don’t want to restrict the `largest` function to the types that implement
-the `Copy` trait, we could specify that `T` has the trait bound `Clone` instead
-of `Copy`. Then we could clone each value in the slice when we want the
-`largest` function to have ownership. Using the `clone` function means we’re
-potentially making more heap allocations in the case of types that own heap
-data like `String`, and heap allocations can be slow if we’re working with
-large amounts of data.
-
-Another way we could implement `largest` is for the function to return a
-reference to a `T` value in the slice. If we change the return type to `&T`
-instead of `T`, thereby changing the body of the function to return a
-reference, we wouldn’t need the `Clone` or `Copy` trait bounds and we could
-avoid heap allocations. Try implementing these alternate solutions on your own!
+Because we bound `T` to `std::cmp::PartialOrd`, `T` can now use the `PartialOrd`'s
+default implementation of the `>` operator!
 
 ### Using Trait Bounds to Conditionally Implement Methods