Errata

in the sentence,
"because Rust requires that the code deal with both variants of the Error enum"

`Error` should be `Result`.

"actually a different function (tname::<u32> or tname::<Square>):"

"tname::<Square>" should be "tname::<Vec<i32>>", for this example.

Note from the Author or Editor:
(p.165 of printed book, last paragraph)

(Reported by HIDEMOTO NAKADA)

The paragraphs describing `Borrow` and `ToOwned` are somewhat confused and unhelpful. A better version would be:

The standard library's container types have more realistic uses of `Borrow`. For example, `HashMap::get`uses `Borrow` to allow convenient retrieval of entries by reference to the either the key's actual type `K`, or to some other type that it can be borrowed as. For example, a `HashMap` keyed by `String` can `get` entries via either `&String` or `&str`.

The `ToOwned`trait builds on the `Borrow` trait, adding a `to_owned()` method that produces a new owned item from the borrowed type. This is a generalization of the `Clone` trait: where `Clone` specifically requires a reference `&T` of the same type to produce a new `T`, `ToOwned` instead produces a new `T` from some other type—specifically, the type that's the result of the `borrow()`.

A more concrete example makes this clearer. The standard library allows a `&String` to be converted into a `&str`, via an implementation of `Borrow<str>` for `String`. A new `String` instance can be `clone`d from a `&String` reference, but to get a new `String` from a `&str` reference, the `ToOwned` implementation that the standard library provides (for `str`) is needed.

Although it's not (just) a pointer type, the `Cow` type is worth mentioning at this point, because it uses `ToOwned` to cope with a combination of borrowed and owned data. `Cow` is an `enum` that can hold either owned data or a reference to borrowed data. The peculiar name stands for "clone-on-write": a `Cow` input can remain as borrowed data right up to the point where it needs to be modified, but it becomes an owned copy (using `ToOwned`) at the point where the data needs to be altered.

The text says "The code can't implement Default for chrono::Utc because...", but in the code example time::Date is used, also the error message says "the trait `Default` is not implemented for `Date`". Looks for me like in a previous version chrono::Utc was used and now time::Data, but the text was forgotten to adapt?

Note from the Author or Editor:
Yes, the text needs an update to replace `chrono::Utc` with `time::Date` to match the code.

(Spotted by Alan Stokes)

"- Like a C/C++ pointer or reference, a Rust reference can be modified after creation to refer to something different."

should read:

"- Like a C/C++ pointer, a Rust reference can be modified after creation to refer to something different."

(because C++ references can't be rebound)

(Spotted by Alan Stokes)

Cow does not actually need unsafe internally; its functionality is provided using safe code. So a different example would be better here, e.g. replace the whole bullet with:

"- The `std::sync::atomic` module provides atomic versions of primitive types."