From b6a357c4319cb3acd9ad5a82f647eae05aab7664 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:27:18 -0800
Subject: [PATCH 01/26] Fix C++ this. to this-> (compilation error)

In C++ 'this' is a pointer, not a reference. Using 'this.member' will
not compile. Changed to 'this->member' in inheritance_and_reuse.md and
object_identity.md.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/data_modeling/inheritance_and_reuse.md | 4 ++--
 src/idioms/object_identity.md                     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/idioms/data_modeling/inheritance_and_reuse.md b/src/idioms/data_modeling/inheritance_and_reuse.md
index debb1a6..e1a5870 100644
--- a/src/idioms/data_modeling/inheritance_and_reuse.md
+++ b/src/idioms/data_modeling/inheritance_and_reuse.md
@@ -33,12 +33,12 @@ class Printer : public Device {
     bool powered = false;
 public:
     void powerOn() override {
-        this.powered = true;
+        this->powered = true;
         std::cout << "Printer is powered on." << std::endl;
     }
 
     void powerOff() override {
-        this.powered = false;
+        this->powered = false;
         std::cout << "Printer is powered off." << std::endl;
     }
 };
diff --git a/src/idioms/object_identity.md b/src/idioms/object_identity.md
index c97a914..f70b4c3 100644
--- a/src/idioms/object_identity.md
+++ b/src/idioms/object_identity.md
@@ -40,7 +40,7 @@ struct Person
     Person& operator=(const Person& other) {
         // compare object identity first
         if (this != &other) {
-            this.name = other.name;
+            this->name = other.name;
             // copy the other expensive-to-copy fields
         }
 

From 25f9d65f768b1580e53dadab0dd1f7b57386354a Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:27:32 -0800
Subject: [PATCH 02/26] Fix uninitialized loop variable in C++ example (UB)

The for loops in placement_new.md declared 'std::size_t i;' without
initialization, producing undefined behavior. Added '= 0' to both
loop variable declarations.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/placement_new.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/idioms/placement_new.md b/src/idioms/placement_new.md
index e222326..4768d72 100644
--- a/src/idioms/placement_new.md
+++ b/src/idioms/placement_new.md
@@ -169,12 +169,12 @@ int main() {
   constexpr unsigned int SIZE = 8000000;
   std::unique_ptr b = std::make_unique<
       std::array<unsigned int, SIZE>>();
-  for (std::size_t i; i < SIZE; ++i) {
+  for (std::size_t i = 0; i < SIZE; ++i) {
     (*b)[i] = 42;
   }
 
   // use b so that it isn't optimized away
-  for (std::size_t i; i < SIZE; ++i) {
+  for (std::size_t i = 0; i < SIZE; ++i) {
     std::cout << (*b)[i] << std::endl;
   }
 }

From 698ea57c5bee7204ad1f2dc7f36e5c92bf2edf48 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:27:48 -0800
Subject: [PATCH 03/26] Fix twice() computing square instead of double

The function named 'twice' was computing n * n (squaring) instead of
n * 2 (doubling). Fixed in both the C++ and Rust examples in the
function-to-pointer section of promotions_and_conversions.md.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/promotions_and_conversions.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/idioms/promotions_and_conversions.md b/src/idioms/promotions_and_conversions.md
index 4337a04..b9c42aa 100644
--- a/src/idioms/promotions_and_conversions.md
+++ b/src/idioms/promotions_and_conversions.md
@@ -99,7 +99,7 @@ do not have function type, but can also be converted to function pointers.
 
 ```cpp
 int twice(int n) {
-  return n * n;
+  return n * 2;
 }
 
 struct MyPair {
@@ -139,7 +139,7 @@ int main() {
 
 ```rust
 fn twice(x: i32) -> i32 {
-    x * x
+    x * 2
 }
 
 struct MyPair(i32, i32);

From bee11aee0eab0c35c4e6e18c7fca821124d104e1 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:27:59 -0800
Subject: [PATCH 04/26] Fix normalization math error in setters_and_getters
 example

The unit vector check was computing x^2 + xy instead of x^2 + y^2.
Changed 'v.y * v.x' to 'v.y * v.y' in the Normalized::from_vec2
method.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/encapsulation/setters_and_getters.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/idioms/encapsulation/setters_and_getters.md b/src/idioms/encapsulation/setters_and_getters.md
index 9fa14ac..506033c 100644
--- a/src/idioms/encapsulation/setters_and_getters.md
+++ b/src/idioms/encapsulation/setters_and_getters.md
@@ -119,7 +119,7 @@ fn sqrt_approx_zero(x: f64) -> bool {
 
 impl Normalized {
     pub fn from_vec2(v: Vec2) -> Option<Self> {
-        if sqrt_approx_zero(v.x * v.x + v.y * v.x - 1.0) {
+        if sqrt_approx_zero(v.x * v.x + v.y * v.y - 1.0) {
             Some(Self(v))
         } else {
             None

From 0c370cd67bb534cbca3a51bacb6ff4ea68016179 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:28:13 -0800
Subject: [PATCH 05/26] Fix Optional<Box<T>> to Option<Box<T>> in
 sentinel_values

Used the C++ name 'Optional' instead of the Rust type name 'Option'.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/null/sentinel_values.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/idioms/null/sentinel_values.md b/src/idioms/null/sentinel_values.md
index 9b0a18c..751ba6f 100644
--- a/src/idioms/null/sentinel_values.md
+++ b/src/idioms/null/sentinel_values.md
@@ -53,7 +53,7 @@ The `Box<T>` type has the same meaning as `std::unique_ptr<T>` in terms of being
 a uniquely owned pointer to some `T` on the heap, but unlike `std::unique_ptr`,
 it cannot be null. Rust's `Option<T>` (which is similar to `std::optional<T>` in
 C++) can represent optional pointers when used in conjunction with `Box<T>`, as
-in `Optional<Box<T>>`. In [those cases (and in some other
+in `Option<Box<T>>`. In [those cases (and in some other
 cases)](../data_modeling/template_specialization.md#niche-optimization) the
 compiler optimizes the representation to be the same size as `Box<T>` by
 leveraging the fact that `Box` cannot be null.

From 6557dac3a78087437c7f2d44f8deaadc5291b10b Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:28:53 -0800
Subject: [PATCH 06/26] Fix ErrorB copy-paste error showing ErrorA message

Three instances of the ErrorB C++ struct had a message string saying
"ErrorA was produced" instead of "ErrorB was produced".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/exceptions/expected_errors.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/idioms/exceptions/expected_errors.md b/src/idioms/exceptions/expected_errors.md
index 2f2f344..509ceb7 100644
--- a/src/idioms/exceptions/expected_errors.md
+++ b/src/idioms/exceptions/expected_errors.md
@@ -447,7 +447,7 @@ struct ErrorA : public std::exception {
 void mightThrowA() {}
 
 struct ErrorB : public std::exception {
-  const char *msg = "ErrorA was produced";
+  const char *msg = "ErrorB was produced";
   const char *what() const noexcept override {
     return msg;
   }
@@ -565,7 +565,7 @@ struct ErrorA : public std::exception {
 void mightThrowA() {}
 
 struct ErrorB : public std::exception {
-  const char *msg = "ErrorA was produced";
+  const char *msg = "ErrorB was produced";
   const char *what() const noexcept override {
     return msg;
   }
@@ -645,7 +645,7 @@ struct ErrorA : public std::exception {
 void mightThrowA() {}
 
 struct ErrorB : public std::exception {
-  const char *msg = "ErrorA was produced";
+  const char *msg = "ErrorB was produced";
   const char *what() const noexcept override {
     return msg;
   }

From 40ae09d80af6e98c0870ed8eaa7a66caa88a3944 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:29:08 -0800
Subject: [PATCH 07/26] Fix Rust snake_case violations in expected_errors
 examples

Renamed might_throw_A and might_throw_B to might_throw_a and
might_throw_b to follow Rust's snake_case naming convention.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/exceptions/expected_errors.md | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/idioms/exceptions/expected_errors.md b/src/idioms/exceptions/expected_errors.md
index 509ceb7..17a660b 100644
--- a/src/idioms/exceptions/expected_errors.md
+++ b/src/idioms/exceptions/expected_errors.md
@@ -480,7 +480,7 @@ impl Display for ErrorA {
 
 impl Error for ErrorA {}
 
-fn might_throw_A() -> Result<(), ErrorA> {
+fn might_throw_a() -> Result<(), ErrorA> {
     Ok(())
 }
 
@@ -498,7 +498,7 @@ impl Display for ErrorB {
 
 impl Error for ErrorB {}
 
-fn might_throw_B() -> Result<(), ErrorB> {
+fn might_throw_b() -> Result<(), ErrorB> {
     Ok(())
 }
 
@@ -537,8 +537,8 @@ impl From<ErrorB> for ErrorAOrB {
 
 fn process() -> Result<(), ErrorAOrB> {
     // the ? operator uses the From instance
-    might_throw_A()?;
-    might_throw_B()?;
+    might_throw_a()?;
+    might_throw_b()?;
     Ok(())
 }
 ```
@@ -586,7 +586,7 @@ use thiserror::Error;
 #[error("ErrorA was produced")]
 struct ErrorA;
 
-fn might_throw_A() -> Result<(), ErrorA> {
+fn might_throw_a() -> Result<(), ErrorA> {
     Ok(())
 }
 
@@ -594,7 +594,7 @@ fn might_throw_A() -> Result<(), ErrorA> {
 #[error("ErrorB was produced")]
 struct ErrorB;
 
-fn might_throw_B() -> Result<(), ErrorB> {
+fn might_throw_b() -> Result<(), ErrorB> {
     Ok(())
 }
 
@@ -607,8 +607,8 @@ enum ErrorAOrB {
 }
 
 fn process() -> Result<(), ErrorAOrB> {
-    might_throw_A()?;
-    might_throw_B()?;
+    might_throw_a()?;
+    might_throw_b()?;
     Ok(())
 }
 ```
@@ -676,7 +676,7 @@ use thiserror::Error;
 #[error("ErrorA was produced")]
 struct ErrorA;
 
-fn might_throw_A() -> Result<(), ErrorA> {
+fn might_throw_a() -> Result<(), ErrorA> {
     Ok(())
 }
 
@@ -684,13 +684,13 @@ fn might_throw_A() -> Result<(), ErrorA> {
 #[error("ErrorB was produced")]
 struct ErrorB;
 
-fn might_throw_B() -> Result<(), ErrorB> {
+fn might_throw_b() -> Result<(), ErrorB> {
     Ok(())
 }
 
 fn process() -> anyhow::Result<()> {
-    might_throw_A()?;
-    might_throw_B()?;
+    might_throw_a()?;
+    might_throw_b()?;
     Ok(())
 }
 

From fa7dac3739621926b0a4caea1574889efdc4dd29 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:29:24 -0800
Subject: [PATCH 08/26] Fix Rust camelCase variable names to snake_case

Renamed twicePtr, ctorPtr, methodPtr, closureRes to twice_ptr,
ctor_ptr, method_ptr, closure_res in the function-to-pointer Rust
example in promotions_and_conversions.md.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/promotions_and_conversions.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/idioms/promotions_and_conversions.md b/src/idioms/promotions_and_conversions.md
index b9c42aa..81f3278 100644
--- a/src/idioms/promotions_and_conversions.md
+++ b/src/idioms/promotions_and_conversions.md
@@ -152,22 +152,22 @@ impl MyPair {
 
 fn main() {
     // convert a function to a function pointer
-    let twicePtr: fn(i32) -> i32 = twice;
-    let res = twicePtr(5);
+    let twice_ptr: fn(i32) -> i32 = twice;
+    let res = twice_ptr(5);
 
     // convert a constructor to a function pointer
-    let ctorPtr: fn(i32, i32) -> MyPair = MyPair;
-    let pair = ctorPtr(10, 20);
+    let ctor_ptr: fn(i32, i32) -> MyPair = MyPair;
+    let pair = ctor_ptr(10, 20);
 
     // convert a static method to a function
     // pointer
-    let methodPtr: fn() -> MyPair = MyPair::new;
-    let pair2 = methodPtr();
+    let method_ptr: fn() -> MyPair = MyPair::new;
+    let pair2 = method_ptr();
 
     // convert a non-capturing closure to a
     // function pointer
     let closure: fn(i32) -> i32 = |x: i32| x * 5;
-    let closureRes = closure(2);
+    let closure_res = closure(2);
 }
 ```
 

From 94492d1de9ca8f803444e8e4c062c56ebd9e10d1 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:29:37 -0800
Subject: [PATCH 09/26] Fix subject-verb agreement in abstract_classes.md

Changed 'both requires' to 'both require'.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/data_modeling/abstract_classes.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/idioms/data_modeling/abstract_classes.md b/src/idioms/data_modeling/abstract_classes.md
index e2ddaad..963ccfc 100644
--- a/src/idioms/data_modeling/abstract_classes.md
+++ b/src/idioms/data_modeling/abstract_classes.md
@@ -165,7 +165,7 @@ given by a user defined `Drop` implementation or not) required for the value.
 
 ## Vtables and Rust trait object types
 
-C++ and Rust both requires some kind of indirection to perform dynamic dispatch
+C++ and Rust both require some kind of indirection to perform dynamic dispatch
 against an interface. In C++ this indirection takes the form of a pointer to the
 abstract class (instead of the derived concrete class), making use of a vtable
 to resolve the virtual method.

From ef1a3c6dce415e57bae54bb25a29195bc827c907 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:29:55 -0800
Subject: [PATCH 10/26] Fix typos in templates.md

- 'idomatic' -> 'idiomatic'
- 'defintion' -> 'definition'
- 'using and Rust's' -> 'using Rust's' (extra word)
- 'C++ template' -> 'a C++ template' (missing article)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/data_modeling/templates.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/idioms/data_modeling/templates.md b/src/idioms/data_modeling/templates.md
index 79f83fc..efd30fe 100644
--- a/src/idioms/data_modeling/templates.md
+++ b/src/idioms/data_modeling/templates.md
@@ -91,7 +91,7 @@ impl<Label> DirectedGraph<Label> {
 </div>
 
 In the use case demonstrated in the above example, there are few practical
-differences between using C++ template to define a class and using and Rust's
+differences between using a C++ template to define a class and using Rust's
 generics to define a struct. Whenever one would use a template that takes a
 `typename` or `class` parameter in C++, one can instead take a type parameter in
 Rust.
@@ -197,7 +197,7 @@ impl<Label> DirectedGraph<Label> {
     where
         Label: Ord,
     {
-        // Matches the C++, but is not the idomatic
+        // Matches the C++, but is not the idiomatic
         // implementation!
         if self.node_labels.is_empty() {
             None
@@ -390,7 +390,7 @@ because both are part of the type of the produced array.
 
 ## Rust's `Self` type
 
-Within a Rust struct defintion, `impl` block, or `impl` trait block, there is a
+Within a Rust struct definition, `impl` block, or `impl` trait block, there is a
 `Self` type that is in scope. The `Self` type is the type of the class being
 defined with all of the generic type parameters filled in. It can be useful to
 refer to this type especially in cases where there are many parameters that

From 9a630908bea9472dfa3a4b046d4542a5811fedf1 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:30:14 -0800
Subject: [PATCH 11/26] Fix typos and grammar in overloading.md

- 'with with' -> 'with' (duplicate word)
- 'can either be overloaded either' -> 'can be overloaded either'
- 'operator' -> 'operators' (missing plural)
- 'desireable' -> 'desirable'

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/overloading.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/idioms/overloading.md b/src/idioms/overloading.md
index 5b1ad43..948e937 100644
--- a/src/idioms/overloading.md
+++ b/src/idioms/overloading.md
@@ -119,7 +119,7 @@ fn main() {
 ```
 
 One exception to this is when the methods are all from the same generic trait
-with with different type parameters for the implementations. In that case, if
+with different type parameters for the implementations. In that case, if
 the signature is sufficient to determine which implementation to use, the trait
 does not need to be specified to resolve the method. This is common when using
 the [`From` trait](https://doc.rust-lang.org/std/convert/trait.From.html).
@@ -149,10 +149,10 @@ fn main() {
 
 ## Overloaded operators
 
-In C++ most operators can either be overloaded either with a free-standing
+In C++ most operators can be overloaded either with a free-standing
 function or by providing a method defining the operator on a class.
 
-Rust provides operator via implementation of specific traits. Implementing a
+Rust provides operators via implementation of specific traits. Implementing a
 method of the same name as required by the trait will not make a type usable
 with the operator if the trait is not implemented.
 
@@ -227,7 +227,7 @@ impl std::ops::Add<&Vec2> for &Vec2 {
     }
 }
 
-// If Vec2 weren't so small, it might be desireable to re-use space in the below
+// If Vec2 weren't so small, it might be desirable to re-use space in the below
 // implementations, since they take ownership.
 
 impl std::ops::Add<Vec2> for &Vec2 {

From c82466e5eb4f08cbe16248ca4514c86fe6b75bb4 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:30:37 -0800
Subject: [PATCH 12/26] Fix typos in iterators.md

- 'iterable sequence' -> 'an iterable sequence' (missing article)
- 'accessiable' -> 'accessible' (2 occurrences)
- 'invaliding' -> 'invalidating'

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/iterators.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/idioms/iterators.md b/src/idioms/iterators.md
index 2522d8f..c37579b 100644
--- a/src/idioms/iterators.md
+++ b/src/idioms/iterators.md
@@ -2,7 +2,7 @@
 
 Rust iterators resemble C++
 [ranges](https://en.cppreference.com/w/cpp/ranges.html) in that they represent
-iterable sequence and can be manipulated similarly to using
+an iterable sequence and can be manipulated similarly to using
 range views. Since C++ ranges are defined using iterators and ranges were only
 introduced in C++20, this chapter compares Rust iterators with both C++
 iterators and with C++ ranges.
@@ -222,7 +222,7 @@ fn main() {
         println!("{}", x);
     }
 
-    // since v was borrowed, not moved, it is still accessiable here.
+    // since v was borrowed, not moved, it is still accessible here.
     println!("{:?}", v);
 
     for x in &mut v {
@@ -230,7 +230,7 @@ fn main() {
         x.push('!');
     }
 
-    // since v was borrowed, not moved, it is still accessiable here.
+    // since v was borrowed, not moved, it is still accessible here.
     // however, the content of v has been modified
     println!("{:?}", v);
 
@@ -351,7 +351,7 @@ fn main() {
 ## Iterator invalidation
 
 In C++, operations sometimes only invalidate some iterators on a value, such as
-the `erase` method on `std::vector` only invaliding iterators to the erased
+the `erase` method on `std::vector` only invalidating iterators to the erased
 element and those after it, but not the ones before it.
 
 In Rust, the fact that iterators borrow the whole iterated value means that no

From 76086e2139aacc30e5ad7c83e1f63f80fe3c7e97 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:30:58 -0800
Subject: [PATCH 13/26] Fix 'beacause' typo in visitor.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/patterns/visitor.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/patterns/visitor.md b/src/patterns/visitor.md
index 34adff3..fee4501 100644
--- a/src/patterns/visitor.md
+++ b/src/patterns/visitor.md
@@ -503,7 +503,7 @@ impl Exp for Let {
 // Error for representing expression evaluation
 // errors.
 //
-// Has a lifetime parameter beacause it borrows
+// Has a lifetime parameter because it borrows
 // the name from the expression.
 #[derive(Debug)]
 enum EvalError<'a> {

From 35b1224360b216905bc76ac488bb9872e5c04ff0 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:31:19 -0800
Subject: [PATCH 14/26] Fix grammar errors and TODO in rtti.md

- 'Even when the a client of the library is needs' -> 'Even when a
  client of the library needs'
- 'an be used' -> 'can be used'
- 'can managing' -> 'can manage'
- Replace TODO comment with actual link to visitor pattern chapter

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/rtti.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/idioms/rtti.md b/src/idioms/rtti.md
index b17862e..129103f 100644
--- a/src/idioms/rtti.md
+++ b/src/idioms/rtti.md
@@ -130,7 +130,7 @@ fn handle_event(e: Event) {
 
 </div>
 
-Even when the a client of the library is needs to be able to define custom
+Even when a client of the library needs to be able to define custom
 events, it is usually possible to make use of an event enum. This is the
 approach taken by the [winit
 crate](https://docs.rs/winit/latest/winit/event/enum.Event.html), which does
@@ -238,14 +238,14 @@ fn handle_event(e: Event<UserEvent>) {
 </div>
 
 When representing events as an enum truly isn't feasible, sometimes double
-dispatch <!-- TODO: link to visitor --> can be used instead. Otherwise it may be
+dispatch ([the visitor pattern](../patterns/visitor.md)) can be used instead. Otherwise it may be
 necessary to use the `Any` trait or to define an `Event` trait that exposes a
-type identifier that an be used for safe downcasting (via `Any`) or unsafe
+type identifier that can be used for safe downcasting (via `Any`) or unsafe
 downcasting behind a safe interface.[^safe-event-handler]
 
 [^safe-event-handler]: Such an interface usually involves providing individual
     event handling functions for specific types, rather than a single large
-    event handling function, so that the underlying implementation can managing
+    event handling function, so that the underlying implementation can manage
     the enforcement of the invariants required to make the casting safe.
 
 ## Library support for reflection via macros

From 9276ce382b7d1e396a2616b70aa2a9b03109ca19 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:31:48 -0800
Subject: [PATCH 15/26] Fix typos in placement_new.md and rvo.md

- 'Unless otherwise state' -> 'Unless otherwise stated' (both files)
- 'the The Rust Unstable Book' -> 'the Rust Unstable Book'
- 'what is need' -> 'what is needed'

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/placement_new.md | 6 +++---
 src/idioms/rvo.md           | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/idioms/placement_new.md b/src/idioms/placement_new.md
index 4768d72..48cb5e4 100644
--- a/src/idioms/placement_new.md
+++ b/src/idioms/placement_new.md
@@ -3,7 +3,7 @@
 <div class="warning">
 
 Some of the statements about Rust in this chapter are dependent on the specifics
-of how the compiler optimizes various programs. Unless otherwise state, the
+of how the compiler optimizes various programs. Unless otherwise stated, the
 results presented here are based on rustc 1.87 using the [2024 language
 edition](https://doc.rust-lang.org/edition-guide/introduction.html).
 
@@ -39,7 +39,7 @@ available when using the nightly compiler with [a feature
 flag](https://doc.rust-lang.org/unstable-book/library-features/allocator-api.html).
 The Rust Book has [instructions on how to install the nightly
 toolchain](https://doc.rust-lang.org/book/appendix-07-nightly-rust.html#unstable-features)
-and the The Rust Unstable Book has [instructions on how to use unstable
+and the Rust Unstable Book has [instructions on how to use unstable
 features](https://doc.rust-lang.org/unstable-book/).
 
 For stable Rust, there are libraries that cover many of the uses of allocators.
@@ -246,7 +246,7 @@ fn main() {
 }
 ```
 
-Depending on what is need, this particular use can be generalized.
+Depending on what is needed, this particular use can be generalized.
 
 ```rust
 fn init_with<T, const SIZE: usize>(
diff --git a/src/idioms/rvo.md b/src/idioms/rvo.md
index d945584..5b1dbd5 100644
--- a/src/idioms/rvo.md
+++ b/src/idioms/rvo.md
@@ -3,7 +3,7 @@
 <div class="warning">
 
 Some of the statements about Rust in this chapter are dependent on the specifics
-of how the compiler optimizes various programs. Unless otherwise state, the
+of how the compiler optimizes various programs. Unless otherwise stated, the
 results presented here are based on rustc 1.87 using the [2024 language
 edition](https://doc.rust-lang.org/edition-guide/introduction.html) and with
 `-O2` for C++ and `--opt-level=2` for Rust.

From cc224446d6930b458b9127a845db9a17cf437c51 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:34:01 -0800
Subject: [PATCH 16/26] Fix typos and missing article in
 private_constructors.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix "remaning" → "remaining", "accesssible" → "accessible",
"accessbile" → "accessible", and "is not breaking change" →
"is not a breaking change".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/encapsulation/private_constructors.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/idioms/encapsulation/private_constructors.md b/src/idioms/encapsulation/private_constructors.md
index 97b51d4..c7a8154 100644
--- a/src/idioms/encapsulation/private_constructors.md
+++ b/src/idioms/encapsulation/private_constructors.md
@@ -78,7 +78,7 @@ fn main() {
     let carol =
         Person::new("Carol".to_string(), 20);
     // Can match on the public fields, and then
-    // use .. to ignore the remaning ones.
+    // use .. to ignore the remaining ones.
     let Person { name, age, .. } = carol;
 }
 ```
@@ -146,7 +146,7 @@ mod shape {
 use shape::*;
 
 fn main() {
-    // Variant constructor is accesssible despite not being marked pub.
+    // Variant constructor is accessible despite not being marked pub.
     let triangle = Shape::Triangle {
         base: 1.0,
         height: 2.0,
@@ -154,7 +154,7 @@ fn main() {
 
     let circle = Shape::Circle { radius: 1.0 };
 
-    // Fields accessbile despite not being marked pub.
+    // Fields accessible despite not being marked pub.
     match circle {
         Shape::Triangle { base, height } => {
             println!("Triangle: {}, {}", base, height);
@@ -363,7 +363,7 @@ pub enum Shape {
 
 The attribute is more typically used to force clients of a library to include
 the wildcard when matching on the struct fields, making it so that adding
-additional fields to a struct is not breaking change (i.e., that it does not
+additional fields to a struct is not a breaking change (i.e., that it does not
 [require the increase of the major version component when using semantic
 versioning](https://doc.rust-lang.org/cargo/reference/semver.html)).
 

From 94aec27e942f005ed053f9c32fa6f217faa9cc7e Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:34:14 -0800
Subject: [PATCH 17/26] Fix grammar and missing space in
 user-defined_conversions.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix "are is often used" → "are often used" and add missing space
before "trait" in DerefMut link.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/user-defined_conversions.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/idioms/user-defined_conversions.md b/src/idioms/user-defined_conversions.md
index 393ab7b..4cf8afc 100644
--- a/src/idioms/user-defined_conversions.md
+++ b/src/idioms/user-defined_conversions.md
@@ -139,7 +139,7 @@ fn main() {
 
 </div>
 
-Conversion functions are is often used to implement the safe bool pattern in
+Conversion functions are often used to implement the safe bool pattern in
 C++, [which is addressed in a different way in
 Rust](./promotions_and_conversions.md#safe-bools).
 
@@ -332,7 +332,7 @@ Rust does have one kind of user-defined implicit conversion, called [deref
 coercions](https://doc.rust-lang.org/std/ops/trait.Deref.html#deref-coercion),
 provided by the [`Deref`
 trait](https://doc.rust-lang.org/std/ops/trait.Deref.html) and
-[`DerefMut`trait](https://doc.rust-lang.org/std/ops/trait.DerefMut.html). These
+[`DerefMut` trait](https://doc.rust-lang.org/std/ops/trait.DerefMut.html). These
 coercions exist for making pointer-like types more ergonomic to use.
 
 An [example](https://doc.rust-lang.org/book/ch15-02-deref.html) of implementing

From 30384d5bd3318a2ffcb15d4975463ce68ff26f02 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:34:23 -0800
Subject: [PATCH 18/26] Fix subject-verb agreement in sentinel_values.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix "are in-band value that indicates" → "are in-band values
that indicate".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/null/sentinel_values.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/idioms/null/sentinel_values.md b/src/idioms/null/sentinel_values.md
index 751ba6f..283d2d1 100644
--- a/src/idioms/null/sentinel_values.md
+++ b/src/idioms/null/sentinel_values.md
@@ -1,6 +1,6 @@
 # Sentinel values
 
-Sentinel values are in-band value that indicates a special situation, such as
+Sentinel values are in-band values that indicate a special situation, such as
 having reached the end of valid data in an iterator.
 
 ## `nullptr`

From 49fe939807b5388b60d1f65a9a2eb107ec057337 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:34:42 -0800
Subject: [PATCH 19/26] Fix grammar and clarify wording in
 promotions_and_conversions.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix "intended to used be indices" → "intended to be used as indices",
"This results a situation" → "This results in a situation", and
clarify "constructors (proper constructors)" → "tuple struct
constructors".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/promotions_and_conversions.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/idioms/promotions_and_conversions.md b/src/idioms/promotions_and_conversions.md
index 81f3278..b2b2362 100644
--- a/src/idioms/promotions_and_conversions.md
+++ b/src/idioms/promotions_and_conversions.md
@@ -91,7 +91,7 @@ In C++ functions and static member functions are automatically converted to
 function pointers.
 
 Rust performs the same conversion. In addition to functions and members that do
-not take `self` as an argument, constructors (proper constructors) also have
+not take `self` as an argument, tuple struct constructors also have
 function type and can be converted to function pointers. Non-capturing closures
 do not have function type, but can also be converted to function pointers.
 
@@ -285,9 +285,9 @@ fn main() {
 ### `isize` and `usize`
 
 In the Rust standard library the `isize` and `usize` types are used for values
-intended to used be indices (much like `size_t` in C++). However, their use for
+intended to be used as indices (much like `size_t` in C++). However, their use for
 other purposes is usually discouraged in favor of using explicitly sized types
-such as `u32`. This results a situation where values of type `u32` have to be
+such as `u32`. This results in a situation where values of type `u32` have to be
 converted to `usize` for use in indexing, but `Into<usize>` is not implemented
 for `u32`.
 

From 80ca769010cb89074a28ea0081affa1b31c900df Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:34:50 -0800
Subject: [PATCH 20/26] Fix 'build in' to 'built-in' in build_systems.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/etc/build_systems.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/etc/build_systems.md b/src/etc/build_systems.md
index e2662d2..d86091d 100644
--- a/src/etc/build_systems.md
+++ b/src/etc/build_systems.md
@@ -6,7 +6,7 @@ repository for a project, while Rust has a central language-specific package
 registry called [crates.io](https://crates.io/).
 
 This difference is amplified by the fact that the Rust build tool, Cargo, has a
-build in package manager that works with crates.io, private registries, local
+built-in package manager that works with crates.io, private registries, local
 packages, and vendored sources.
 
 Cargo is documented in detail in the [Cargo

From 4a9e1b43c84cd07c3b60b25d826e24cd2ec34320 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:35:08 -0800
Subject: [PATCH 21/26] Fix article 'a' to 'an' before 'encapsulated' in
 private_and_friends.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/encapsulation/private_and_friends.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/idioms/encapsulation/private_and_friends.md b/src/idioms/encapsulation/private_and_friends.md
index 14d05dc..ea1c487 100644
--- a/src/idioms/encapsulation/private_and_friends.md
+++ b/src/idioms/encapsulation/private_and_friends.md
@@ -110,7 +110,7 @@ class of `BinaryTree`.
 
 In Rust, however, both types can be defined in the same module, and so have
 access to each other's private fields and methods. The module as a whole
-provides a collection of types, methods, and functions that together define a
+provides a collection of types, methods, and functions that together define an
 encapsulated concept.
 
 <div class="comparison">

From 3b94a5a254e6db526199cc4db988177ee079b8b8 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:35:22 -0800
Subject: [PATCH 22/26] Fix missing article and plural in
 inheritance_and_reuse.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix "in few more ways" → "in a few more ways" and "traits
implementations" → "trait implementations".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/data_modeling/inheritance_and_reuse.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/idioms/data_modeling/inheritance_and_reuse.md b/src/idioms/data_modeling/inheritance_and_reuse.md
index e1a5870..cb5dd82 100644
--- a/src/idioms/data_modeling/inheritance_and_reuse.md
+++ b/src/idioms/data_modeling/inheritance_and_reuse.md
@@ -100,7 +100,7 @@ dispatch](./concepts.md) (with [no vtable overhead in the
 static dispatch
 case](./abstract_classes.md#vtables-and-rust-trait-object-types)).
 
-Rust traits differ from abstract classes in few more ways. For example,
+Rust traits differ from abstract classes in a few more ways. For example,
 Rust traits cannot define data members and cannot define private or protected
 methods. This limits the effectiveness of using traits to implement the template
 method pattern.
@@ -112,7 +112,7 @@ visible as methods on the type.
 Traits can, however, inherit from each other, including multiple inheritance. As
 in modern C++, inheritance hierarchies in Rust tend to be shallow. In situations
 with complex multiple inheritance, however, the diamond problem cannot arise in
-Rust because traits cannot override other traits implementations. Therefore, all
+Rust because traits cannot override other trait implementations. Therefore, all
 paths to a common parent trait resolve to the same implementation.
 
 {{#quiz inheritance_and_reuse.toml}}

From 45837868e8d78d3873d349a173dc53ac787dc578 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:35:30 -0800
Subject: [PATCH 23/26] Fix 'a methods' to 'a method' in setters_and_getters.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/encapsulation/setters_and_getters.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/idioms/encapsulation/setters_and_getters.md b/src/idioms/encapsulation/setters_and_getters.md
index 506033c..48e5139 100644
--- a/src/idioms/encapsulation/setters_and_getters.md
+++ b/src/idioms/encapsulation/setters_and_getters.md
@@ -139,7 +139,7 @@ impl Normalized {
 
 A significant limitation that arises from the way that getter methods interact
 with the borrow checker is that it isn't possible to mutably borrow multiple
-elements from an indexed structure like a vector using a methods like
+elements from an indexed structure like a vector using a method like
 `Vec::get_mut`.
 
 The built-in indexed types have several methods for creating split views onto a

From e53aee34c4f7e6252c1f927a757b8282d9303e7e Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:35:39 -0800
Subject: [PATCH 24/26] Fix grammar in object_identity.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix "others cases" → "other cases" and remove duplicated "by" in
"handled by instead by".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/object_identity.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/idioms/object_identity.md b/src/idioms/object_identity.md
index f70b4c3..bdbe940 100644
--- a/src/idioms/object_identity.md
+++ b/src/idioms/object_identity.md
@@ -11,8 +11,8 @@ between specific instances of an object that otherwise have the same properties.
 For example, representing a labeled graph where there may be distinct nodes that
 have the same label.
 
-In Rust, some of these cases are not applicable, and others cases are typically
-handled by instead by implementing a synthetic notion of identity for the
+In Rust, some of these cases are not applicable, and other cases are typically
+handled instead by implementing a synthetic notion of identity for the
 values.
 
 ## Overloading copy assignment and equality comparison operators

From 1f67bca43875dc0854a746561f51a24f38eb7c26 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:35:49 -0800
Subject: [PATCH 25/26] Fix missing word in expected_errors.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix "The most approach depends" → "The best approach depends".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/idioms/exceptions/expected_errors.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/idioms/exceptions/expected_errors.md b/src/idioms/exceptions/expected_errors.md
index 17a660b..24c3d81 100644
--- a/src/idioms/exceptions/expected_errors.md
+++ b/src/idioms/exceptions/expected_errors.md
@@ -109,7 +109,7 @@ fn main() {
 In C++, the only way to handle exceptions is `catch`. In Rust, all of the
 features for dealing with [tagged
 unions](../data_modeling/tagged_unions.md) can be used with `Result` and
-`Option`. The most approach depends on the intention of the program.
+`Option`. The best approach depends on the intention of the program.
 
 The basic way of handling an error indicated by a `Result` in Rust is by using
 `match`.

From 34d86644599698d1ad2f63cd8eb07246dfb94699 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Wed, 11 Feb 2026 11:36:00 -0800
Subject: [PATCH 26/26] Remove empty link from Concurrency entry in SUMMARY.md

The concurrency chapter doesn't exist yet, so remove the empty
link brackets to avoid a broken link in the rendered book.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/SUMMARY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 813e43d..d8e2dee 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -45,7 +45,7 @@
 - [Rust and C++ interoperability (FFI)](./idioms/ffi.md)
 - [NRVO and RVO](./idioms/rvo.md)
 - [Placement new](./idioms/placement_new.md)
-- [Concurrency (threads and async)]()
+- Concurrency (threads and async)
 
 # Patterns