-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `ArgumentError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `ArgumentError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/encodingerror.rs w/spinoso-exception/src/core/encodingerror.rs
index bce3a2e8a1..04313d98f3 100644
--- i/spinoso-exception/src/core/encodingerror.rs
+++ w/spinoso-exception/src/core/encodingerror.rs
@@ -45,15 +45,14 @@ impl EncodingError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"EncodingError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `EncodingError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `EncodingError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/eoferror.rs w/spinoso-exception/src/core/eoferror.rs
index 65fa57f16e..deef23437d 100644
--- i/spinoso-exception/src/core/eoferror.rs
+++ w/spinoso-exception/src/core/eoferror.rs
@@ -46,15 +46,14 @@ impl EOFError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"EOFError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `EOFError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `EOFError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/exception.rs w/spinoso-exception/src/core/exception.rs
index add5b17347..0fd23e2a1f 100644
--- i/spinoso-exception/src/core/exception.rs
+++ w/spinoso-exception/src/core/exception.rs
@@ -45,15 +45,14 @@ impl Exception {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"Exception";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `Exception` Ruby exception with the given
-    /// message.
+    /// Construct a new, `Exception` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/fatal.rs w/spinoso-exception/src/core/fatal.rs
index ba05401c89..32e2846d41 100644
--- i/spinoso-exception/src/core/fatal.rs
+++ w/spinoso-exception/src/core/fatal.rs
@@ -45,15 +45,14 @@ impl Fatal {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"fatal";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `fatal` Ruby exception with the given
-    /// message.
+    /// Construct a new, `fatal` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/fibererror.rs w/spinoso-exception/src/core/fibererror.rs
index 2a57d97961..e51fe9b622 100644
--- i/spinoso-exception/src/core/fibererror.rs
+++ w/spinoso-exception/src/core/fibererror.rs
@@ -45,15 +45,14 @@ impl FiberError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"FiberError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `FiberError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `FiberError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/floatdomainerror.rs w/spinoso-exception/src/core/floatdomainerror.rs
index d69464b0ff..92e7023cf4 100644
--- i/spinoso-exception/src/core/floatdomainerror.rs
+++ w/spinoso-exception/src/core/floatdomainerror.rs
@@ -45,9 +45,9 @@ impl FloatDomainError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"FloatDomainError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }
diff --git i/spinoso-exception/src/core/frozenerror.rs w/spinoso-exception/src/core/frozenerror.rs
index a68be40b7b..380c7358bf 100644
--- i/spinoso-exception/src/core/frozenerror.rs
+++ w/spinoso-exception/src/core/frozenerror.rs
@@ -45,15 +45,14 @@ impl FrozenError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"FrozenError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `FrozenError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `FrozenError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/indexerror.rs w/spinoso-exception/src/core/indexerror.rs
index dd61dcf331..970214c051 100644
--- i/spinoso-exception/src/core/indexerror.rs
+++ w/spinoso-exception/src/core/indexerror.rs
@@ -45,15 +45,14 @@ impl IndexError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"IndexError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `IndexError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `IndexError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/interrupt.rs w/spinoso-exception/src/core/interrupt.rs
index f9924ca1ea..3c7fa3cdae 100644
--- i/spinoso-exception/src/core/interrupt.rs
+++ w/spinoso-exception/src/core/interrupt.rs
@@ -45,15 +45,14 @@ impl Interrupt {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"Interrupt";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `Interrupt` Ruby exception with the given
-    /// message.
+    /// Construct a new, `Interrupt` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/ioerror.rs w/spinoso-exception/src/core/ioerror.rs
index 0f926d29d9..96c214ece6 100644
--- i/spinoso-exception/src/core/ioerror.rs
+++ w/spinoso-exception/src/core/ioerror.rs
@@ -46,15 +46,14 @@ impl IOError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"IOError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `IOError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `IOError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/keyerror.rs w/spinoso-exception/src/core/keyerror.rs
index b5049f24c3..f46ec41427 100644
--- i/spinoso-exception/src/core/keyerror.rs
+++ w/spinoso-exception/src/core/keyerror.rs
@@ -45,15 +45,14 @@ impl KeyError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"KeyError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `KeyError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `KeyError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/loaderror.rs w/spinoso-exception/src/core/loaderror.rs
index 93b0ce489f..c281941608 100644
--- i/spinoso-exception/src/core/loaderror.rs
+++ w/spinoso-exception/src/core/loaderror.rs
@@ -45,15 +45,14 @@ impl LoadError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"LoadError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `LoadError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `LoadError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/localjumperror.rs w/spinoso-exception/src/core/localjumperror.rs
index 470a9430ed..d6cd4757a2 100644
--- i/spinoso-exception/src/core/localjumperror.rs
+++ w/spinoso-exception/src/core/localjumperror.rs
@@ -45,15 +45,14 @@ impl LocalJumpError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"LocalJumpError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `LocalJumpError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `LocalJumpError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/nameerror.rs w/spinoso-exception/src/core/nameerror.rs
index 6a1912d8c5..83c2f72c77 100644
--- i/spinoso-exception/src/core/nameerror.rs
+++ w/spinoso-exception/src/core/nameerror.rs
@@ -45,15 +45,14 @@ impl NameError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"NameError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `NameError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `NameError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/nomemoryerror.rs w/spinoso-exception/src/core/nomemoryerror.rs
index c629495ed3..581db5baeb 100644
--- i/spinoso-exception/src/core/nomemoryerror.rs
+++ w/spinoso-exception/src/core/nomemoryerror.rs
@@ -45,15 +45,14 @@ impl NoMemoryError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"NoMemoryError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `NoMemoryError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `NoMemoryError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/nomethoderror.rs w/spinoso-exception/src/core/nomethoderror.rs
index 51eb9cc97d..f56c0e8c03 100644
--- i/spinoso-exception/src/core/nomethoderror.rs
+++ w/spinoso-exception/src/core/nomethoderror.rs
@@ -45,15 +45,14 @@ impl NoMethodError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"NoMethodError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `NoMethodError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `NoMethodError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/notimplementederror.rs w/spinoso-exception/src/core/notimplementederror.rs
index e736cd650e..08e355513c 100644
--- i/spinoso-exception/src/core/notimplementederror.rs
+++ w/spinoso-exception/src/core/notimplementederror.rs
@@ -45,9 +45,9 @@ impl NotImplementedError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"NotImplementedError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }
diff --git i/spinoso-exception/src/core/rangeerror.rs w/spinoso-exception/src/core/rangeerror.rs
index 1559606ff4..eac71799fe 100644
--- i/spinoso-exception/src/core/rangeerror.rs
+++ w/spinoso-exception/src/core/rangeerror.rs
@@ -45,15 +45,14 @@ impl RangeError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"RangeError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `RangeError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `RangeError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/regexperror.rs w/spinoso-exception/src/core/regexperror.rs
index 05a44aca00..418358d434 100644
--- i/spinoso-exception/src/core/regexperror.rs
+++ w/spinoso-exception/src/core/regexperror.rs
@@ -45,15 +45,14 @@ impl RegexpError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"RegexpError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `RegexpError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `RegexpError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/runtimeerror.rs w/spinoso-exception/src/core/runtimeerror.rs
index 11eb629e7d..116690f327 100644
--- i/spinoso-exception/src/core/runtimeerror.rs
+++ w/spinoso-exception/src/core/runtimeerror.rs
@@ -45,15 +45,14 @@ impl RuntimeError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"RuntimeError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `RuntimeError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `RuntimeError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/scripterror.rs w/spinoso-exception/src/core/scripterror.rs
index c632f5a862..0322b08048 100644
--- i/spinoso-exception/src/core/scripterror.rs
+++ w/spinoso-exception/src/core/scripterror.rs
@@ -45,15 +45,14 @@ impl ScriptError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"ScriptError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `ScriptError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `ScriptError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/securityerror.rs w/spinoso-exception/src/core/securityerror.rs
index f8706531e6..20b5467c4f 100644
--- i/spinoso-exception/src/core/securityerror.rs
+++ w/spinoso-exception/src/core/securityerror.rs
@@ -45,15 +45,14 @@ impl SecurityError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"SecurityError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `SecurityError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `SecurityError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/signalexception.rs w/spinoso-exception/src/core/signalexception.rs
index 77e01b511b..28246a0382 100644
--- i/spinoso-exception/src/core/signalexception.rs
+++ w/spinoso-exception/src/core/signalexception.rs
@@ -45,9 +45,9 @@ impl SignalException {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"SignalException";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }
diff --git i/spinoso-exception/src/core/standarderror.rs w/spinoso-exception/src/core/standarderror.rs
index 310e75db53..c5e8c1de78 100644
--- i/spinoso-exception/src/core/standarderror.rs
+++ w/spinoso-exception/src/core/standarderror.rs
@@ -45,15 +45,14 @@ impl StandardError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"StandardError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `StandardError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `StandardError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/stopiteration.rs w/spinoso-exception/src/core/stopiteration.rs
index 9653d851a6..5309cffba2 100644
--- i/spinoso-exception/src/core/stopiteration.rs
+++ w/spinoso-exception/src/core/stopiteration.rs
@@ -45,15 +45,14 @@ impl StopIteration {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"StopIteration";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `StopIteration` Ruby exception with the given
-    /// message.
+    /// Construct a new, `StopIteration` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/syntaxerror.rs w/spinoso-exception/src/core/syntaxerror.rs
index 84556aba49..89784c1715 100644
--- i/spinoso-exception/src/core/syntaxerror.rs
+++ w/spinoso-exception/src/core/syntaxerror.rs
@@ -45,15 +45,14 @@ impl SyntaxError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"SyntaxError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `SyntaxError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `SyntaxError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/systemcallerror.rs w/spinoso-exception/src/core/systemcallerror.rs
index eac05c8bf7..8c1e8f8727 100644
--- i/spinoso-exception/src/core/systemcallerror.rs
+++ w/spinoso-exception/src/core/systemcallerror.rs
@@ -45,9 +45,9 @@ impl SystemCallError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"SystemCallError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }
diff --git i/spinoso-exception/src/core/systemexit.rs w/spinoso-exception/src/core/systemexit.rs
index 96fcc43e02..cb1e6287cc 100644
--- i/spinoso-exception/src/core/systemexit.rs
+++ w/spinoso-exception/src/core/systemexit.rs
@@ -45,15 +45,14 @@ impl SystemExit {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"SystemExit";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `SystemExit` Ruby exception with the given
-    /// message.
+    /// Construct a new, `SystemExit` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/systemstackerror.rs w/spinoso-exception/src/core/systemstackerror.rs
index 1d7f73b580..dc767c7539 100644
--- i/spinoso-exception/src/core/systemstackerror.rs
+++ w/spinoso-exception/src/core/systemstackerror.rs
@@ -45,9 +45,9 @@ impl SystemStackError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"SystemStackError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }
diff --git i/spinoso-exception/src/core/threaderror.rs w/spinoso-exception/src/core/threaderror.rs
index 9f55fb12e2..90a09a19f5 100644
--- i/spinoso-exception/src/core/threaderror.rs
+++ w/spinoso-exception/src/core/threaderror.rs
@@ -45,15 +45,14 @@ impl ThreadError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"ThreadError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `ThreadError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `ThreadError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/typeerror.rs w/spinoso-exception/src/core/typeerror.rs
index f099b21a2d..591e1c9912 100644
--- i/spinoso-exception/src/core/typeerror.rs
+++ w/spinoso-exception/src/core/typeerror.rs
@@ -45,15 +45,14 @@ impl TypeError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"TypeError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }

-    /// Construct a new, `TypeError` Ruby exception with the given
-    /// message.
+    /// Construct a new, `TypeError` Ruby exception with the given message.
     ///
     /// # Examples
     ///
diff --git i/spinoso-exception/src/core/uncaughtthrowerror.rs w/spinoso-exception/src/core/uncaughtthrowerror.rs
index 3f7de347a8..9b35f69fba 100644
--- i/spinoso-exception/src/core/uncaughtthrowerror.rs
+++ w/spinoso-exception/src/core/uncaughtthrowerror.rs
@@ -45,9 +45,9 @@ impl UncaughtThrowError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"UncaughtThrowError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }
diff --git i/spinoso-exception/src/core/zerodivisionerror.rs w/spinoso-exception/src/core/zerodivisionerror.rs
index 02d692e0cb..faad1c22a1 100644
--- i/spinoso-exception/src/core/zerodivisionerror.rs
+++ w/spinoso-exception/src/core/zerodivisionerror.rs
@@ -45,9 +45,9 @@ impl ZeroDivisionError {
     pub const fn new() -> Self {
         const DEFAULT_MESSAGE: &[u8] = b"ZeroDivisionError";

-        // `Exception` objects initialized via (for example)
-        // `raise RuntimeError` or `RuntimeError.new` have `message`
-        // equal to the exception's class name.
+        // `Exception` objects initialized via (for example) `raise RuntimeError`
+         //or `RuntimeError.new` have `message` equal to the exception's class
+        //name.
         let message = Cow::Borrowed(DEFAULT_MESSAGE);
         Self { message }
     }
diff --git i/spinoso-math/src/lib.rs w/spinoso-math/src/lib.rs
index 7fbc09aea2..32099630a1 100644
--- i/spinoso-math/src/lib.rs
+++ w/spinoso-math/src/lib.rs
@@ -196,9 +196,9 @@ impl error::Error for Error {
 ///
 /// Domain errors have an associated message.
 ///
-/// This error corresponds to the [Ruby `Math::DomainError` Exception class]. It
-/// can be used to differentiate between [`NaN`](f64::NAN) inputs and what would
-/// be `NaN` outputs.
+/// This error corresponds to the [Ruby `Math::DomainError`
+/// `Math::DomainError` Exception class]. It can be used to differentiate
+/// between [`NaN`](f64::NAN) inputs and what would be `NaN` outputs.
 ///
 /// # Examples
 ///
diff --git i/spinoso-math/src/math.rs w/spinoso-math/src/math.rs
index cd8610803a..30428d9be8 100644
--- i/spinoso-math/src/math.rs
+++ w/spinoso-math/src/math.rs
@@ -208,8 +208,8 @@ pub fn atan2(value: f64, other: f64) -> f64 {
 ///
 /// # Errors
 ///
-/// If the result of computing the inverse hyperbolic tangent is [`NAN`]
-/// a domain error is returned.
+/// If the result of computing the inverse hyperbolic tangent is [`NAN`] a
+/// domain error is returned.
 ///
 /// [`NAN`]: f64::NAN
 #[inline]
@@ -486,29 +486,12 @@ pub fn gamma(value: f64) -> Result<f64, DomainError> {
     // and might be an approximation so include a lookup table for as many `n`
     // as can fit in the float mantissa.
     const FACTORIAL_TABLE: [f64; 23] = [
-        1.0_f64,                         // fact(0)
-        1.0,                             // fact(1)
-        2.0,                             // fact(2)
-        6.0,                             // fact(3)
-        24.0,                            // fact(4)
-        120.0,                           // fact(5)
-        720.0,                           // fact(6)
-        5_040.0,                         // fact(7)
-        40_320.0,                        // fact(8)
-        362_880.0,                       // fact(9)
-        3_628_800.0,                     // fact(10)
-        39_916_800.0,                    // fact(11)
-        479_001_600.0,                   // fact(12)
-        6_227_020_800.0,                 // fact(13)
-        87_178_291_200.0,                // fact(14)
-        1_307_674_368_000.0,             // fact(15)
-        20_922_789_888_000.0,            // fact(16)
-        355_687_428_096_000.0,           // fact(17)
-        6_402_373_705_728_000.0,         // fact(18)
-        121_645_100_408_832_000.0,       // fact(19)
-        2_432_902_008_176_640_000.0,     // fact(20)
-        51_090_942_171_709_440_000.0,    // fact(21)
-        1_124_000_727_777_607_680_000.0, // fact(22)
+        1.0_f64,                         // fact(0) fact(1) fact(2) fact(3)
+                                          //fact(4) fact(5) fact(6) fact(7)
+                                         //fact(8) fact(9) fact(10) fact(11)
+                                         //fact(12) fact(13) fact(14) fact(15)
+                                         //fact(16) fact(17) fact(18) fact(19)
+                                         //fact(20) fact(21) fact(22)
     ];
     match value {
         value if value.is_infinite() && value.is_sign_negative() => Err(DomainError::with_message(
diff --git i/spinoso-random/src/lib.rs w/spinoso-random/src/lib.rs
index 710453fdf5..c3088ddd3f 100644
--- i/spinoso-random/src/lib.rs
+++ w/spinoso-random/src/lib.rs
@@ -265,7 +265,8 @@ impl error::Error for InitializeError {}
 /// This error is returned by [`urandom()`]. See its documentation for more
 /// details.
 ///
-/// This error corresponds to the [Ruby `RuntimeError` Exception class].
+/// This error corresponds to the [Ruby `RuntimeError`
+/// `RuntimeError` Exception class].
 ///
 /// # Examples
 ///
@@ -332,7 +333,8 @@ impl error::Error for UrandomError {}
 /// This error is returned by [`new_seed`]. See its documentation for more
 /// details.
 ///
-/// This error corresponds to the [Ruby `RuntimeError` Exception class].
+/// This error corresponds to the [Ruby `RuntimeError`
+/// `RuntimeError` Exception class].
 ///
 /// # Examples
 ///
@@ -397,7 +399,8 @@ impl error::Error for NewSeedError {}
 /// This error is returned by [`rand()`]. See its documentation for more
 /// details.
 ///
-/// This error corresponds to the [Ruby `ArgumentError` Exception class].
+/// This error corresponds to the [Ruby `ArgumentError`
+/// `ArgumentError` Exception class].
 ///
 /// # Examples
 ///
diff --git i/spinoso-regexp/src/debug.rs w/spinoso-regexp/src/debug.rs
index 794adeb4ca..d55f583fc1 100644
--- i/spinoso-regexp/src/debug.rs
+++ w/spinoso-regexp/src/debug.rs
@@ -52,8 +52,7 @@ impl Delimiters {
 ///
 /// # Examples
 ///
-/// UTF-8 regexp patterns and options are formatted in a debug
-/// representation:
+/// UTF-8 regexp patterns and options are formatted in a debug representation:
 ///
 /// ```
 /// use spinoso_regexp::Debug;
@@ -95,8 +94,9 @@ pub struct Debug<'a> {
 }

 impl<'a> Debug<'a> {
-    /// Construct a new `Debug` iterator with a regexp source, [options
-    /// modifiers], and [encoding modifiers].
+    /// Construct a new `Debug` iterator with a regexp source,
+    /// [options
+ modifiers], and [encoding modifiers].
     ///
     /// # Examples
     ///
@@ -199,8 +199,8 @@ impl<'a> Iterator for Debug<'a> {
                     self.source = &self.source[size..];
                     Some(ch)
                 }
-                // Otherwise, we've gotten invalid UTF-8, which means this is not a
-                // printable char.
+                // Otherwise, we've gotten invalid UTF-8, which means this is not
+                 //a printable char.
                 None => {
                     let (chunk, remainder) = self.source.split_at(size);
                     self.source = remainder;
diff --git i/spinoso-regexp/src/encoding.rs w/spinoso-regexp/src/encoding.rs
index 879da6a0a7..179bf7d89a 100644
--- i/spinoso-regexp/src/encoding.rs
+++ w/spinoso-regexp/src/encoding.rs
@@ -32,10 +32,10 @@ impl error::Error for InvalidEncodingError {}

 /// The encoding of a Regexp literal.
 ///
-/// Regexps are assumed to use the source encoding but literals may override
-/// the encoding with a Regexp modifier.
+/// Regexps are assumed to use the source encoding but literals may override the
+/// encoding with a Regexp modifier.
 ///
-/// See [`Regexp` encoding][regexp-encoding].
+/// See [`Regexp` [`Regexp` encoding][regexp-encoding].
 ///
 /// [regexp-encoding]: https://ruby-doc.org/core-3.1.2/Regexp.html#class-Regexp-label-Encoding
 #[derive(Debug, Clone, Copy, PartialOrd, Ord)]
diff --git i/spinoso-regexp/src/error.rs w/spinoso-regexp/src/error.rs
index 00aceb73f6..656a74c08a 100644
--- i/spinoso-regexp/src/error.rs
+++ w/spinoso-regexp/src/error.rs
@@ -63,7 +63,8 @@ impl error::Error for Error {
 ///
 /// Argument errors have an associated message.
 ///
-/// This error corresponds to the [Ruby `ArgumentError` Exception class].
+/// This error corresponds to the [Ruby `ArgumentError`
+/// `ArgumentError` Exception class].
 ///
 /// # Examples
 ///
diff --git i/spinoso-regexp/src/lib.rs w/spinoso-regexp/src/lib.rs
index d360452d54..71f4242047 100644
--- i/spinoso-regexp/src/lib.rs
+++ w/spinoso-regexp/src/lib.rs
@@ -3,8 +3,7 @@
 #![warn(clippy::cargo)]
 #![cfg_attr(test, allow(clippy::non_ascii_literal))]
 #![allow(unknown_lints)]
-// TODO: warn on missing docs once crate is API-complete.
-// #![warn(missing_docs)]
+// TODO: warn on missing docs once crate is API-complete. #![warn(missing_docs)]
 #![warn(missing_debug_implementations)]
 #![warn(missing_copy_implementations)]
 #![warn(rust_2018_idioms)]
diff --git i/spinoso-regexp/src/options.rs w/spinoso-regexp/src/options.rs
index b3d63ec0d5..72d0826007 100644
--- i/spinoso-regexp/src/options.rs
+++ w/spinoso-regexp/src/options.rs
@@ -112,8 +112,8 @@ impl From<u8> for Options {
 impl From<i64> for Options {
     /// Truncate the given `i64` to one byte and generate flags.
     ///
-    /// See `From<u8>`. For a conversion that fails if the given `i64` is
-    /// larger than [`u8::MAX`], see [`try_from_int`].
+    /// See `From<u8>`. For a conversion that fails if the given `i64` is larger
+    /// than [`u8::MAX`], see [`try_from_int`].
     ///
     /// [`try_from_int`]: Self::try_from_int
     fn from(flags: i64) -> Self {
@@ -487,7 +487,8 @@ mod tests {

     #[test]
     fn make_options_all_opts() {
-        // `ALL_REGEXP_OPTS` is equivalent to `EXTENDED | IGNORECASE | MULTILINE` flags.
+        // `ALL_REGEXP_OPTS` is equivalent to
+         //`EXTENDED | IGNORECASE | MULTILINE` flags.
         let mut opts = Options::new();
         opts.flags |= Flags::ALL_REGEXP_OPTS;
         assert_ne!(Options::from(Flags::EXTENDED), opts);
diff --git i/spinoso-regexp/src/regexp/regex/utf8/mod.rs w/spinoso-regexp/src/regexp/regex/utf8/mod.rs
index d623fa4c19..8fae30ccb3 100644
--- i/spinoso-regexp/src/regexp/regex/utf8/mod.rs
+++ w/spinoso-regexp/src/regexp/regex/utf8/mod.rs
@@ -215,7 +215,8 @@ impl Utf8 {
         Ok(pos)
     }

-    /// Check whether this regexp matches the given haystack starting at an offset.
+    /// Check whether this regexp matches the given haystack starting at an
+    /// offset.
     ///
     /// If the given offset is negative, it counts backward from the end of the
     /// haystack.
@@ -392,9 +393,8 @@ mod tests {
             (B("xyz"), "xyz"),
             (B("🦀"), "🦀"),
             (B("铁锈"), "铁锈"),
-            // Invalid UTF-8 patterns are not supported 👇
-            // (B(b"\xFF\xFE"), r"\xFF\xFE"),
-            // (B(b"abc \xFF\xFE xyz"), r"abc \xFF\xFE xyz"),
+            // Invalid UTF-8 patterns are not supported 👇 (B(b"\xFF\xFE"),
+             //r"\xFF\xFE"), (B(b"abc \xFF\xFE xyz"), r"abc \xFF\xFE xyz"),
         ];
         for (pattern, display) in test_cases {
             let regexp = make(pattern, None, Encoding::None);
@@ -411,7 +411,8 @@ mod tests {
             (B("\0"), r"/\x00/m", Options::from(Flags::MULTILINE)),
             (B(b"\x0a"), "/\n/", Options::default()),
             (B("\x0B"), "/\x0B/", Options::default()),
-            // NOTE: the control characters, not a raw string, are in the debug output.
+            // NOTE: the control characters, not a raw string, are in the debug
+             //output.
             (B("\n\r\t"), "/\n\r\t/", Options::default()),
             (B("\n\r\t"), "/\n\r\t/mix", Options::from(Flags::ALL_REGEXP_OPTS)),
             (
@@ -460,9 +461,9 @@ mod tests {
             ),
             (B("铁锈"), "/铁锈/m", Options::from(Flags::MULTILINE)),
             (B("铁+锈*"), "/铁+锈*/mix", Options::from(Flags::ALL_REGEXP_OPTS)),
-            // Invalid UTF-8 patterns are not supported 👇
-            // (B(b"\xFF\xFE"), r"\xFF\xFE", Options::default()),
-            // (B(b"abc \xFF\xFE xyz"), r"abc \xFF\xFE xyz", Options::default()),
+            // Invalid UTF-8 patterns are not supported 👇 (B(b"\xFF\xFE"),
+             //r"\xFF\xFE", Options::default()), (B(b"abc \xFF\xFE xyz"), r"abc
+            //\xFF\xFE xyz", Options::default()),
         ];
         for (pattern, debug, options) in test_cases {
             let regexp = make(pattern, Some(options), Encoding::None);
diff --git i/spinoso-securerandom/src/lib.rs w/spinoso-securerandom/src/lib.rs
index 2e1c5fc642..7aa7792c4d 100644
--- i/spinoso-securerandom/src/lib.rs
+++ w/spinoso-securerandom/src/lib.rs
@@ -127,7 +127,8 @@ pub enum Error {
     /// This may mean that too many random bytes were requested or the system is
     /// out of memory.
     ///
-    /// See [`TryReserveError`] and [`TryReserveErrorKind`] for more information.
+    /// See [`TryReserveError`] and [`TryReserveErrorKind`] for more
+    /// information.
     ///
     /// [`TryReserveErrorKind`]: std::collections::TryReserveErrorKind
     Memory(TryReserveError),
@@ -182,7 +183,8 @@ impl error::Error for Error {
 ///
 /// Argument errors have an associated message.
 ///
-/// This error corresponds to the [Ruby `ArgumentError` Exception class].
+/// This error corresponds to the [Ruby `ArgumentError`
+/// `ArgumentError` Exception class].
 ///
 /// # Examples
 ///
@@ -472,15 +474,15 @@ pub fn random_bytes(len: Option<i64>) -> Result<Vec<u8>, Error> {
 pub enum Max {
     /// Generate floats in the range `[0, max)`.
     ///
-    /// If `max` is less than or equal to zero, the range defaults to floats
-    /// in `[0.0, 1.0]`.
+    /// If `max` is less than or equal to zero, the range defaults to floats in
+    /// `[0.0, 1.0]`.
     ///
     /// If `max` is [`NaN`](f64::NAN), an error is returned.
     Float(f64),
     /// Generate signed integers in the range `[0, max)`.
     ///
-    /// If `max` is less than or equal to zero, the range defaults to floats
-    /// in `[0.0, 1.0]`.
+    /// If `max` is less than or equal to zero, the range defaults to floats in
+    /// `[0.0, 1.0]`.
     Integer(i64),
     /// Generate floats in the range `[0.0, 1.0]`.
     None,
@@ -679,8 +681,8 @@ pub fn urlsafe_base64(len: Option<i64>, padding: bool) -> Result<String, Error>

 /// Generate a random sequence of ASCII alphanumeric bytes.
 ///
-/// If `len` is [`Some`] and non-negative, generate a [`String`] of `len`
-/// random ASCII alphanumeric bytes. If `len` is [`None`], generate 16 random
+/// If `len` is [`Some`] and non-negative, generate a [`String`] of `len` random
+/// ASCII alphanumeric bytes. If `len` is [`None`], generate 16 random
 /// alphanumeric bytes.
 ///
 /// The returned [`Vec<u8>`](Vec) is guaranteed to contain only ASCII bytes.
diff --git i/spinoso-securerandom/src/uuid.rs w/spinoso-securerandom/src/uuid.rs
index 719128c0cc..0b5fa40974 100644
--- i/spinoso-securerandom/src/uuid.rs
+++ w/spinoso-securerandom/src/uuid.rs
@@ -17,8 +17,7 @@ use crate::{Error, RandomBytesError};
 /// [RFC 4122, Section 4.1]: https://tools.ietf.org/html/rfc4122#section-4.1
 const OCTETS: usize = 16;

-// See the BNF from JDK 8 that confirms stringified UUIDs are 36 characters
-// long:
+// See the BNF from JDK 8 that confirms stringified UUIDs are 36 characters long:
 //
 // https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--
 const ENCODED_LENGTH: usize = 36;
@@ -33,7 +32,8 @@ pub fn v4() -> Result<String, Error> {
     let mut bytes = [0; OCTETS];
     get_random_bytes(OsRng, &mut bytes)?;

-    // Per RFC 4122, Section 4.4, set bits for version and `clock_seq_hi_and_reserved`.
+    // Per RFC 4122, Section 4.4, set bits for version and
+     //`clock_seq_hi_and_reserved`.
     bytes[6] = (bytes[6] & 0x0f) | 0x40;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;

diff --git i/spinoso-string/src/buf/nul_terminated_vec.rs w/spinoso-string/src/buf/nul_terminated_vec.rs
index 8f7abe334a..dbe0afce4d 100644
--- i/spinoso-string/src/buf/nul_terminated_vec.rs
+++ w/spinoso-string/src/buf/nul_terminated_vec.rs
@@ -15,8 +15,7 @@ fn ensure_nul_terminated(vec: &mut Vec<u8>) {
     const NUL_BYTE: u8 = 0;

     let spare_capacity = vec.spare_capacity_mut();
-    // If the vec has spare capacity, set the first and last bytes to NUL.
-    // See:
+    // If the vec has spare capacity, set the first and last bytes to NUL. See:
     //
     // - https://github.com/artichoke/artichoke/pull/1976#discussion_r932782264
     // - https://github.com/artichoke/artichoke/blob/16c869a9ad29acfe143bfcc011917ef442ccac54/artichoke-backend/vendor/mruby/src/string.c#L36-L38
@@ -88,8 +87,8 @@ impl Deref for Buf {
 impl DerefMut for Buf {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
-        // SAFETY: the mutable reference given out is a slice, NOT the
-        // underlying `Vec`, so the allocation cannot change size.
+        // SAFETY: the mutable reference given out is a slice, NOT the underlying
+         //`Vec`, so the allocation cannot change size.
         &mut *self.inner
     }
 }
diff --git i/spinoso-string/src/chars.rs w/spinoso-string/src/chars.rs
index a54dbb5e20..50597bcef7 100644
--- i/spinoso-string/src/chars.rs
+++ w/spinoso-string/src/chars.rs
@@ -197,7 +197,8 @@ impl<'a> Iterator for ConventionallyUtf8<'a> {
             Some(ch)
         } else {
             let (invalid_utf8_bytes, remainder) = self.bytes.split_at(size);
-            // Invalid UTF-8 bytes are yielded as byte slices one byte at a time.
+            // Invalid UTF-8 bytes are yielded as byte slices one byte at a
+             //time.
             self.invalid_bytes = InvalidBytes::with_bytes(invalid_utf8_bytes);
             self.bytes = remainder;
             self.invalid_bytes.next()
diff --git i/spinoso-string/src/codepoints.rs w/spinoso-string/src/codepoints.rs
index 21ba542ffd..80d3aadc3b 100644
--- i/spinoso-string/src/codepoints.rs
+++ w/spinoso-string/src/codepoints.rs
@@ -118,9 +118,9 @@ impl InvalidCodepointError {
         // formatted as `0x...`.
         const MESSAGE_MAX_LENGTH: usize = 27 + 2 + mem::size_of::<u32>() * 2;
         let mut s = alloc::string::String::with_capacity(MESSAGE_MAX_LENGTH);
-        // In practice, the errors from `write!` below are safe to ignore
-        // because the `core::fmt::Write` impl for `String` will never panic
-        // and these `String`s will never approach `isize::MAX` bytes.
+        // In practice, the errors from `write!` below are safe to ignore because
+         //the `core::fmt::Write` impl for `String` will never panic and these
+        //`String`s will never approach `isize::MAX` bytes.
         //
         // See the `core::fmt::Display` impl for `InvalidCodepointError`.
         let _ = write!(s, "{}", self);
diff --git i/spinoso-string/src/enc/mod.rs w/spinoso-string/src/enc/mod.rs
index f152a7856d..a24896635c 100644
--- i/spinoso-string/src/enc/mod.rs
+++ w/spinoso-string/src/enc/mod.rs
@@ -93,9 +93,9 @@ impl Ord for EncodedString {
 //
 // Per the docs in `std`:
 //
-// > In particular `Eq`, `Ord` and `Hash` must be equivalent for borrowed and
-// > owned values: `x.borrow() == y.borrow()` should give the same result as
-// > `x == y`.
+// > In particular `Eq`, `Ord` and `Hash` must be equivalent for borrowed and >
+   //owned values: `x.borrow() == y.borrow()` should give the same result as > `x
+//== y`.
 impl Borrow<[u8]> for EncodedString {
     #[inline]
     fn borrow(&self) -> &[u8] {
diff --git i/spinoso-string/src/enc/utf8/mod.rs w/spinoso-string/src/enc/utf8/mod.rs
index 02a633020c..b0b3a5ce66 100644
--- i/spinoso-string/src/enc/utf8/mod.rs
+++ w/spinoso-string/src/enc/utf8/mod.rs
@@ -208,25 +208,26 @@ impl Utf8String {
     #[inline]
     #[must_use]
     pub fn get_char(&self, index: usize) -> Option<&'_ [u8]> {
-        // Fast path rejection for indexes beyond bytesize, which is
-        // cheap to retrieve.
+        // Fast path rejection for indexes beyond bytesize, which is cheap to
+         //retrieve.
         if index >= self.len() {
             return None;
         }
-        // Fast path for trying to treat the conventionally UTF-8 string
-        // as entirely ASCII.
+        // Fast path for trying to treat the conventionally UTF-8 string as
+         //entirely ASCII.
         //
-        // If the string is either all ASCII or all ASCII for a prefix
-        // of the string that contains the range we wish to slice,
-        // fallback to byte slicing as in the ASCII and binary fast path.
+        // If the string is either all ASCII or all ASCII for a prefix of the
+         //string that contains the range we wish to slice, fallback to byte
+        //slicing as in the ASCII and binary fast path.
         let consumed = match self.inner.find_non_ascii_byte() {
             None => return self.inner.get(index..=index),
             Some(idx) if idx > index => return self.inner.get(index..=index),
             Some(idx) => idx,
         };
         let mut slice = &self.inner[consumed..];
-        // TODO: See if we can use `get_unchecked` as implemented in `fn char_len`
-        // Count of "characters" remaining until the `index`th character.
+        // TODO: See if we can use `get_unchecked` as implemented in
+         //`fn char_len` Count of "characters" remaining until the `index`th
+        //character.
         let mut remaining = index - consumed;
         // This loop will terminate when either:
         //
@@ -237,43 +238,39 @@ impl Utf8String {
         // The loop will advance by at least one byte every iteration.
         loop {
             match bstr::decode_utf8(slice) {
-                // If we've run out of slice while trying to find the
-                // `index`th character, the lookup fails and we return `nil`.
+                // If we've run out of slice while trying to find the `index`th
+                 //character, the lookup fails and we return `nil`.
                 (_, 0) => return None,

-                // The next two arms mean we've reached the `index`th
-                // character. Either return the next valid UTF-8
-                // character byte slice or, if the next bytes are an
-                // invalid UTF-8 sequence, the next byte.
+                // The next two arms mean we've reached the `index`th character.
+                 //Either return the next valid UTF-8 character byte slice or, if
+                //the next bytes are an invalid UTF-8 sequence, the next byte.
                 (Some(_), size) if remaining == 0 => return Some(&slice[..size]),
-                // Size is guaranteed to be positive per the first arm
-                // which means this slice operation will not panic.
+                // Size is guaranteed to be positive per the first arm which
+                 //means this slice operation will not panic.
                 (None, _) if remaining == 0 => return Some(&slice[..1]),

-                // We found a single UTF-8 encoded character keep track
-                // of the count and advance the substring to continue
-                // decoding.
+                // We found a single UTF-8 encoded character keep track of the
+                 //count and advance the substring to continue decoding.
                 (Some(_), size) => {
                     slice = &slice[size..];
                     remaining -= 1;
                 }

-                // The next two arms handle the case where we have
-                // encountered an invalid UTF-8 byte sequence.
+                // The next two arms handle the case where we have encountered an
+                 //invalid UTF-8 byte sequence.
                 //
-                // In this case, `decode_utf8` will return slices whose
-                // length is `1..=3`. The length of this slice is the
-                // number of "characters" we can advance the loop by.
+                // In this case, `decode_utf8` will return slices whose length is
+                 //`1..=3`. The length of this slice is the number of
+                //"characters" we can advance the loop by.
                 //
-                // If the invalid UTF-8 sequence contains more bytes
-                // than we have remaining to get to the `index`th char,
-                // then the target character is inside the invalid UTF-8
-                // sequence.
+                // If the invalid UTF-8 sequence contains more bytes than we have
+                 //remaining to get to the `index`th char, then the target
+                //character is inside the invalid UTF-8 sequence.
                 (None, size) if remaining < size => return Some(&slice[remaining..=remaining]),
-                // If there are more characters remaining than the number
-                // of bytes yielded in the invalid UTF-8 byte sequence,
-                // count `size` bytes and advance the slice to continue
-                // decoding.
+                // If there are more characters remaining than the number of
+                 //bytes yielded in the invalid UTF-8 byte sequence, count `size`
+                //bytes and advance the slice to continue decoding.
                 (None, size) => {
                     slice = &slice[size..];
                     remaining -= size;
@@ -328,8 +325,8 @@ impl Utf8String {
             return Some(&[]);
         }

-        // If the start of the range is beyond the character count of the
-        // string, the whole lookup must fail.
+        // If the start of the range is beyond the character count of the string,
+         //the whole lookup must fail.
         //
         // Slice lookups where the start is just beyond the last character index
         // always return an empty slice.
@@ -395,24 +392,23 @@ impl Utf8String {
             _ => {}
         }

-        // Fast path for trying to treat the conventionally UTF-8 string
-        // as entirely ASCII.
+        // Fast path for trying to treat the conventionally UTF-8 string as
+         //entirely ASCII.
         //
-        // If the string is either all ASCII or all ASCII for the subset
-        // of the string we wish to slice, fallback to byte slicing as in
-        // the ASCII and binary fast path.
+        // If the string is either all ASCII or all ASCII for the subset of the
+         //string we wish to slice, fallback to byte slicing as in the ASCII and
+        //binary fast path.
         //
-        // Perform the same saturate-to-end slicing mechanism if `end`
-        // is beyond the character length of the string.
+        // Perform the same saturate-to-end slicing mechanism if `end` is beyond
+         //the character length of the string.
         let consumed = match self.inner.find_non_ascii_byte() {
-            // The entire string is ASCII, so byte indexing <=> char
-            // indexing.
+            // The entire string is ASCII, so byte indexing <=> char indexing.
             None => return self.inner.get(start..end).or_else(|| self.inner.get(start..)),
-            // The whole substring we are interested in is ASCII, so
-            // byte indexing is still valid.
+            // The whole substring we are interested in is ASCII, so byte
+             //indexing is still valid.
             Some(non_ascii_byte_offset) if non_ascii_byte_offset > end => return self.get(start..end),
-            // We turn non-ASCII somewhere inside before the substring
-            // we're interested in, so consume that much.
+            // We turn non-ASCII somewhere inside before the substring we're
+             //interested in, so consume that much.
             Some(non_ascii_byte_offset) if non_ascii_byte_offset <= start => non_ascii_byte_offset,
             // This means we turn non-ASCII somewhere inside the substring.
             // Consume up to start.
@@ -436,12 +432,10 @@ impl Utf8String {
                     // `start`th character, the lookup fails and we return `nil`.
                     (_, 0) => return None,

-                    // We found a single UTF-8 encoded character. keep track
-                    // of the count and advance the substring to continue
-                    // decoding.
+                    // We found a single UTF-8 encoded character. keep track of
+                     //the count and advance the substring to continue decoding.
                     //
-                    // If there's only one more to go, advance and stop the
-                    // loop.
+                    // If there's only one more to go, advance and stop the loop.
                     (Some(_), size) if remaining == 1 => break &slice[size..],
                     // Otherwise, keep track of the character we observed and
                     // advance the slice to continue decoding.
@@ -457,14 +451,13 @@ impl Utf8String {
                     // length is `1..=3`. The length of this slice is the
                     // number of "characters" we can advance the loop by.
                     //
-                    // If the invalid UTF-8 sequence contains more bytes
-                    // than we have remaining to get to the `start`th char,
-                    // then we can break the loop directly.
+                    // If the invalid UTF-8 sequence contains more bytes than we
+                     //have remaining to get to the `start`th char, then we can
+                    //break the loop directly.
                     (None, size) if remaining <= size => break &slice[remaining..],
-                    // If there are more characters remaining than the number
-                    // of bytes yielded in the invalid UTF-8 byte sequence,
-                    // count `size` bytes and advance the slice to continue
-                    // decoding.
+                    // If there are more characters remaining than the number of
+                     //bytes yielded in the invalid UTF-8 byte sequence, count
+                    //`size` bytes and advance the slice to continue decoding.
                     (None, size) => {
                         slice = &slice[size..];
                         remaining -= size;
@@ -475,12 +468,11 @@ impl Utf8String {

         // Scan the slice for the span of characters we want to return.
         remaining = end - start;
-        // We know `remaining` is not zero because we fast-pathed that
-        // case above.
+        // We know `remaining` is not zero because we fast-pathed that case
+         //above.
         debug_assert!(remaining > 0);

-        // keep track of the start of the substring from the `start`th
-        // character.
+        // keep track of the start of the substring from the `start`th character.
         let substr = slice;

         // This loop will terminate when either:
@@ -496,38 +488,36 @@ impl Utf8String {
                 // character, saturate the slice to the end of the string.
                 (_, 0) => return Some(substr),

-                // We found a single UTF-8 encoded character. keep track
-                // of the count and advance the substring to continue
-                // decoding.
+                // We found a single UTF-8 encoded character. keep track of the
+                 //count and advance the substring to continue decoding.
                 //
-                // If there's only one more to go, advance and stop the
-                // loop.
+                // If there's only one more to go, advance and stop the loop.
                 (Some(_), size) if remaining == 1 => {
-                    // Push `endth` more positive because this match has
-                    // the effect of shrinking `slice`.
+                    // Push `endth` more positive because this match has the
+                     //effect of shrinking `slice`.
                     let endth = substr.len() - slice.len() + size;
                     return Some(&substr[..endth]);
                 }
-                // Otherwise, keep track of the character we observed and
-                // advance the slice to continue decoding.
+                // Otherwise, keep track of the character we observed and advance
+                 //the slice to continue decoding.
                 (Some(_), size) => {
                     slice = &slice[size..];
                     remaining -= 1;
                 }

-                // The next two arms handle the case where we have
-                // encountered an invalid UTF-8 byte sequence.
+                // The next two arms handle the case where we have encountered an
+                 //invalid UTF-8 byte sequence.
                 //
-                // In this case, `decode_utf8` will return slices whose
-                // length is `1..=3`. The length of this slice is the
-                // number of "characters" we can advance the loop by.
+                // In this case, `decode_utf8` will return slices whose length is
+                 //`1..=3`. The length of this slice is the number of
+                //"characters" we can advance the loop by.
                 //
-                // If the invalid UTF-8 sequence contains more bytes
-                // than we have remaining to get to the `end`th char,
-                // then we can break the loop directly.
+                // If the invalid UTF-8 sequence contains more bytes than we have
+                 //remaining to get to the `end`th char, then we can break the
+                //loop directly.
                 (None, size) if remaining <= size => {
-                    // For an explanation of this arithmetic:
-                    // If we're trying to slice:
+                    // For an explanation of this arithmetic: If we're trying to
+                     //slice:
                     //
                     // ```
                     // s = "a\xF0\x9F\x87"
@@ -548,10 +538,9 @@ impl Utf8String {
                     let endth = substr.len() - slice.len() + remaining;
                     return Some(&substr[..endth]);
                 }
-                // If there are more characters remaining than the number
-                // of bytes yielded in the invalid UTF-8 byte sequence,
-                // count `size` bytes and advance the slice to continue
-                // decoding.
+                // If there are more characters remaining than the number of
+                 //bytes yielded in the invalid UTF-8 byte sequence, count `size`
+                //bytes and advance the slice to continue decoding.
                 (None, size) => {
                     slice = &slice[size..];
                     remaining -= size;
@@ -657,19 +646,18 @@ impl Utf8String {
     //       Turkic or ASCII-only modes
     #[inline]
     pub fn make_capitalized(&mut self) {
-        // This allocation assumes that in the common case, capitalizing
-        // and lower-casing `char`s do not change the length of the
-        // `String`.
+        // This allocation assumes that in the common case, capitalizing and
+         //lower-casing `char`s do not change the length of the `String`.
         //
-        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc
-        // fix-up happens instead of alloc fix-ups being O(chars).
+        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc fix-up
+         //happens instead of alloc fix-ups being O(chars).
         let mut replacement = Vec::with_capacity(self.len());
         let mut bytes = self.inner.as_slice();

         match bstr::decode_utf8(bytes) {
             (Some(ch), size) => {
-                // Converting a UTF-8 character to uppercase may yield
-                // multiple codepoints.
+                // Converting a UTF-8 character to uppercase may yield multiple
+                 //codepoints.
                 for ch in ch.to_uppercase() {
                     replacement.push_char(ch);
                 }
@@ -686,8 +674,8 @@ impl Utf8String {
         while !bytes.is_empty() {
             let (ch, size) = bstr::decode_utf8(bytes);
             if let Some(ch) = ch {
-                // Converting a UTF-8 character to lowercase may yield
-                // multiple codepoints.
+                // Converting a UTF-8 character to lowercase may yield multiple
+                 //codepoints.
                 for ch in ch.to_lowercase() {
                     replacement.push_char(ch);
                 }
@@ -703,19 +691,19 @@ impl Utf8String {

     #[inline]
     pub fn make_lowercase(&mut self) {
-        // This allocation assumes that in the common case, lower-casing
-        // `char`s do not change the length of the `String`.
+        // This allocation assumes that in the common case, lower-casing `char`s
+         //do not change the length of the `String`.
         //
-        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc
-        // fix-up happens instead of alloc fix-ups being O(chars).
+        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc fix-up
+         //happens instead of alloc fix-ups being O(chars).
         let mut replacement = Vec::with_capacity(self.len());
         let mut bytes = self.inner.as_slice();

         while !bytes.is_empty() {
             let (ch, size) = bstr::decode_utf8(bytes);
             if let Some(ch) = ch {
-                // Converting a UTF-8 character to lowercase may yield
-                // multiple codepoints.
+                // Converting a UTF-8 character to lowercase may yield multiple
+                 //codepoints.
                 for ch in ch.to_lowercase() {
                     replacement.push_char(ch);
                 }
@@ -731,19 +719,19 @@ impl Utf8String {

     #[inline]
     pub fn make_uppercase(&mut self) {
-        // This allocation assumes that in the common case, upper-casing
-        // `char`s do not change the length of the `String`.
+        // This allocation assumes that in the common case, upper-casing `char`s
+         //do not change the length of the `String`.
         //
-        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc
-        // fix-up happens instead of alloc fix-ups being O(chars).
+        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc fix-up
+         //happens instead of alloc fix-ups being O(chars).
         let mut replacement = Vec::with_capacity(self.len());
         let mut bytes = self.inner.as_slice();

         while !bytes.is_empty() {
             let (ch, size) = bstr::decode_utf8(bytes);
             if let Some(ch) = ch {
-                // Converting a UTF-8 character to lowercase may yield
-                // multiple codepoints.
+                // Converting a UTF-8 character to lowercase may yield multiple
+                 //codepoints.
                 for ch in ch.to_uppercase() {
                     replacement.push_char(ch);
                 }
@@ -795,8 +783,8 @@ impl Utf8String {
         // FIXME: this allocation can go away if `ConventionallyUtf8` impls
         // `DoubleEndedIterator`.
         let chars = ConventionallyUtf8::from(&self.inner[..]).collect::<Vec<_>>();
-        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc
-        // fix-up happens instead of alloc fix-ups being O(chars).
+        // Use a `Vec` here instead of a `Buf` to ensure at most one alloc fix-up
+         //happens instead of alloc fix-ups being O(chars).
         let mut replacement = Vec::with_capacity(self.inner.len());
         for &bytes in chars.iter().rev() {
             replacement.extend_from_slice(bytes);
@@ -949,7 +937,7 @@ mod tests {

     #[test]
     fn char_len_utf8() {
-        // https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L147-L157
+        //          //https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L147-L157
         let s = Utf8String::from("Ω≈ç√∫˜µ≤≥÷");
         assert_eq!(s.char_len(), 10);
         let s = Utf8String::from("åß∂ƒ©˙∆˚¬…æ");
@@ -978,14 +966,14 @@ mod tests {
         // effectively cause rendering issues or character-length issues to
         // validate product globalization readiness.
         //
-        // https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L202-L224
+        //          //https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L202-L224
         let s = Utf8String::from("表ポあA鷗ŒéＢ逍Üßªąñ丂㐀𠀀");
         assert_eq!(s.char_len(), 17);
     }

     #[test]
     fn char_len_two_byte_chars() {
-        // https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L188-L196
+        //          //https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L188-L196
         let s = Utf8String::from("田中さんにあげて下さい");
         assert_eq!(s.char_len(), 11);
         let s = Utf8String::from("パーティーへ行かないか");
@@ -1008,19 +996,21 @@ mod tests {

     #[test]
     fn char_len_space_chars() {
-        // Whitespace: all the characters with category `Zs`, `Zl`, or `Zp` (in Unicode
-        // version 8.0.0), plus `U+0009 (HT)`, `U+000B (VT)`, `U+000C (FF)`, `U+0085 (NEL)`,
-        // and `U+200B` (ZERO WIDTH SPACE), which are in the C categories but are often
-        // treated as whitespace in some contexts.
+        // Whitespace: all the characters with category `Zs`, `Zl`, or `Zp` (in
+         //Unicode version 8.0.0), plus `U+0009 (HT)`, `U+000B (VT)`,
+        //`U+000C (FF)`, `U+0085 (NEL)`, and `U+200B` (ZERO WIDTH SPACE), which
+        //are in the C categories but are often treated as whitespace in some
+        //contexts.
         //
-        // This file unfortunately cannot express strings containing
-        // `U+0000`, `U+000A`, or `U+000D` (`NUL`, `LF`, `CR`).
+        // This file unfortunately cannot express strings containing `U+0000`,
+         //`U+000A`, or `U+000D` (`NUL`, `LF`, `CR`).
         //
         // The next line may appear to be blank or mojibake in some viewers.
         //
-        // The next line may be flagged for "trailing whitespace" in some viewers.
+        // The next line may be flagged for "trailing whitespace" in some
+         //viewers.
         //
-        // https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L131
+        //          //https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L131
         let bytes = "

 ";
         let s = Utf8String::from(bytes);
@@ -1097,7 +1087,8 @@ mod tests {
         // Changes length when case changes
         // https://github.com/minimaxir/big-list-of-naughty-strings/blob/894882e7/blns.txt#L226-L232
         let varying_length = Utf8String::from("zȺȾ");
-        // There doesn't appear to be any RTL scripts that have cases, but might as well make sure
+        // There doesn't appear to be any RTL scripts that have cases, but might
+         //as well make sure
         let rtl = Utf8String::from("مرحبا الخرشوف");

         let capitalize: fn(&Utf8String) -> Utf8String = |value: &Utf8String| {
@@ -1184,16 +1175,17 @@ mod tests {
         //
         // Per `bstr`:
         //
-        // The bytes `\xF0\x9F\x87` could lead to a valid UTF-8 sequence, but 3 of them
-        // on their own are invalid. Only one replacement codepoint is substituted,
-        // which demonstrates the "substitution of maximal subparts" strategy.
+        // The bytes `\xF0\x9F\x87` could lead to a valid UTF-8 sequence, but 3
+         //of them on their own are invalid. Only one replacement codepoint is
+        //substituted, which demonstrates the "substitution of maximal subparts"
+        //strategy.
         let s = Utf8String::from(b"\xF0\x9F\x87");
         assert_eq!(s.chr(), b"\xF0");
     }

     #[test]
     fn get_char_slice_valid_range() {
-        let s = Utf8String::from(b"a\xF0\x9F\x92\x8E\xFF".to_vec()); // "a💎\xFF"
+        let s = Utf8String::from(b"a\xF0\x9F\x92\x8E\xFF".to_vec()); //                                                                       //"a💎\xFF"
         assert_eq!(s.get_char_slice(0..0), Some(&b""[..]));
         assert_eq!(s.get_char_slice(0..1), Some(&b"a"[..]));
         assert_eq!(s.get_char_slice(0..2), Some("a💎".as_bytes()));
@@ -1207,7 +1199,7 @@ mod tests {
     #[test]
     #[allow(clippy::reversed_empty_ranges)]
     fn get_char_slice_invalid_range() {
-        let s = Utf8String::from(b"a\xF0\x9F\x92\x8E\xFF".to_vec()); // "a💎\xFF"
+        let s = Utf8String::from(b"a\xF0\x9F\x92\x8E\xFF".to_vec()); //                                                                       //"a💎\xFF"
         assert_eq!(s.get_char_slice(4..5), None);
         assert_eq!(s.get_char_slice(4..1), None);
         assert_eq!(s.get_char_slice(3..1), Some(&b""[..]));
diff --git i/spinoso-string/src/impls.rs w/spinoso-string/src/impls.rs
index 4b445c16d8..c232e9dae2 100644
--- i/spinoso-string/src/impls.rs
+++ w/spinoso-string/src/impls.rs
@@ -206,15 +206,15 @@ impl DerefMut for String {
     }
 }

-// This impl of `Borrow<[u8]>` is permissible due to the behavior of
-// `PartialEq`, `Hash`, and `Ord` impls on `String` which only rely on the byte
-// slice contents in the underlying encoded string.
+// This impl of `Borrow<[u8]>` is permissible due to the behavior of `PartialEq`,
+ //`Hash`, and `Ord` impls on `String` which only rely on the byte slice contents
+//in the underlying encoded string.
 //
 // Per the docs in `std`:
 //
-// > In particular `Eq`, `Ord` and `Hash` must be equivalent for borrowed and
-// > owned values: `x.borrow() == y.borrow()` should give the same result as
-// > `x == y`.
+// > In particular `Eq`, `Ord` and `Hash` must be equivalent for borrowed and >
+   //owned values: `x.borrow() == y.borrow()` should give the same result as > `x
+//== y`.
 impl Borrow<[u8]> for String {
     #[inline]
     fn borrow(&self) -> &[u8] {
diff --git i/spinoso-string/src/inspect.rs w/spinoso-string/src/inspect.rs
index 5be7b04e2b..1d02b5046c 100644
--- i/spinoso-string/src/inspect.rs
+++ w/spinoso-string/src/inspect.rs
@@ -87,9 +87,9 @@ impl<'a> Inspect<'a> {
     /// Write an `Inspect` iterator into the given destination using the debug
     /// representation of the byte buffer associated with a source `String`.
     ///
-    /// This formatter writes content like `"spinoso"` and `"invalid-\xFF-utf8"`.
-    /// To see example output of the underlying iterator, see the `Inspect`
-    /// documentation.
+    /// This formatter writes content like `"spinoso"` and
+    /// `"invalid-\xFF-utf8"`. To see example output of the underlying iterator,
+    /// see the `Inspect` documentation.
     ///
     /// To write binary output, use [`write_into`], which requires the **std**
     /// feature to be activated.
@@ -134,9 +134,9 @@ impl<'a> Inspect<'a> {
     /// Write an `Inspect` iterator into the given destination using the debug
     /// representation of the byte buffer associated with a source `String`.
     ///
-    /// This formatter writes content like `"spinoso"` and `"invalid-\xFF-utf8"`.
-    /// To see example output of the underlying iterator, see the `Inspect`
-    /// documentation.
+    /// This formatter writes content like `"spinoso"` and
+    /// `"invalid-\xFF-utf8"`. To see example output of the underlying iterator,
+    /// see the `Inspect` documentation.
     ///
     /// To write to a [formatter], use [`format_into`].
     ///
diff --git i/spinoso-string/src/iter.rs w/spinoso-string/src/iter.rs
index 67cfce8623..b6b61e4225 100644
--- i/spinoso-string/src/iter.rs
+++ w/spinoso-string/src/iter.rs
@@ -143,8 +143,8 @@ impl<'a> IterMut<'a> {

     /// Views the underlying data as a subslice of the original data.
     ///
-    /// To avoid creating `&mut` references that alias, this is forced to consume
-    /// the iterator.
+    /// To avoid creating `&mut` references that alias, this is forced to
+    /// consume the iterator.
     ///
     /// # Examples
     ///
diff --git i/spinoso-string/src/lib.rs w/spinoso-string/src/lib.rs
index 87bb579728..3b8f0be089 100644
--- i/spinoso-string/src/lib.rs
+++ w/spinoso-string/src/lib.rs
@@ -3,8 +3,7 @@
 #![warn(clippy::cargo)]
 #![cfg_attr(test, allow(clippy::non_ascii_literal))]
 #![allow(unknown_lints)]
-// TODO: warn on missing docs once crate is API-complete.
-// #![warn(missing_docs)]
+// TODO: warn on missing docs once crate is API-complete. #![warn(missing_docs)]
 #![warn(missing_debug_implementations)]
 #![warn(missing_copy_implementations)]
 #![warn(rust_2018_idioms)]
@@ -282,8 +281,8 @@ impl String {
     /// If `len` is greater than the string's current length, this has no
     /// effect.
     ///
-    /// Note that this method has no effect on the allocated capacity
-    /// of the string.
+    /// Note that this method has no effect on the allocated capacity of the
+    /// string.
     ///
     /// # Examples
     ///
@@ -416,7 +415,8 @@ impl String {
     /// using one of the safe operations instead, such as [`truncate`],
     /// [`extend`], or [`clear`].
     ///
-    /// This function can change the return value of [`String::is_valid_encoding`].
+    /// This function can change the return value of
+    /// [`String::is_valid_encoding`].
     ///
     /// # Safety
     ///
@@ -805,16 +805,14 @@ impl String {
         self.inner.reserve_exact(additional);
     }

-    /// Tries to reserve the minimum capacity for exactly `additional`
-    /// elements to be inserted in the `String`. After calling
-    /// `try_reserve_exact`, capacity will be greater than or equal to
-    /// `self.len() + additional` if it returns `Ok(())`. Does nothing if the
-    /// capacity is already sufficient.
+    /// Tries to reserve the minimum capacity for exactly `additional` elements
+    /// to be inserted in the `String`. After calling `try_reserve_exact`,
+    /// capacity will be greater than or equal to `self.len() + additional` if
+    /// it returns `Ok(())`. Does nothing if the capacity is already sufficient.
     ///
-    /// Note that the allocator may give the collection more space than
-    /// it requests. Therefore, capacity can not be relied upon to be
-    /// precisely minimal. Prefer [`try_reserve`] if future insertions are
-    /// expected.
+    /// Note that the allocator may give the collection more space than it
+    /// requests. Therefore, capacity can not be relied upon to be precisely
+    /// minimal. Prefer [`try_reserve`] if future insertions are expected.
     ///
     /// # Errors
     ///
@@ -1050,8 +1048,8 @@ impl String {
     ///
     /// # Examples
     ///
-    /// For [UTF-8] strings, the given codepoint is converted to a Unicode scalar
-    /// value before appending:
+    /// For [UTF-8] strings, the given codepoint is converted to a Unicode
+    /// scalar value before appending:
     ///
     /// ```
     /// use spinoso_string::String;
@@ -1356,9 +1354,9 @@ impl String {
     pub fn unicode_casecmp(&self, other: &String, options: CaseFold) -> Option<bool> {
         let left = self.as_slice();
         let right = other.as_slice();
-        // If both `String`s are conventionally UTF-8, they must be case
-        // compared using the given case folding strategy. This requires the
-        // `String`s be well-formed UTF-8.
+        // If both `String`s are conventionally UTF-8, they must be case compared
+         //using the given case folding strategy. This requires the `String`s be
+        //well-formed UTF-8.
         if let (Encoding::Utf8, Encoding::Utf8) = (self.encoding(), other.encoding()) {
             if let (Ok(left), Ok(right)) = (str::from_utf8(left), str::from_utf8(right)) {
                 // Both slices are UTF-8, compare with the given Unicode case
@@ -1494,8 +1492,8 @@ impl String {
     #[inline]
     #[must_use]
     pub fn chomp<T: AsRef<[u8]>>(&mut self, separator: Option<T>) -> bool {
-        // convert to a concrete type and delegate to a single `chomp` impl
-        // to minimize code duplication when monomorphizing.
+        // convert to a concrete type and delegate to a single `chomp` impl to
+         //minimize code duplication when monomorphizing.
         if let Some(sep) = separator {
             chomp(self, Some(sep.as_ref()))
         } else {
@@ -1505,7 +1503,8 @@ impl String {

     /// Modifies this `String` in-place and removes the last character.
     ///
-    /// This method returns a [`bool`] that indicates if this string was modified.
+    /// This method returns a [`bool`] that indicates if this string was
+    /// modified.
     ///
     /// If the string ends with `\r\n`, both characters are removed. When
     /// applying `chop` to an empty string, the string remains empty.
@@ -1642,18 +1641,19 @@ impl String {
             if let Some(offset) = offset {
                 let buf = buf.get(offset..)?;
                 let index = buf.find(needle)?;
-                // This addition is guaranteed not to overflow because the result is
-                // a valid index of the underlying `Vec`.
+                // This addition is guaranteed not to overflow because the result
+                 //is a valid index of the underlying `Vec`.
                 //
-                // `self.buf.len() < isize::MAX` because `self.buf` is a `Vec` and
-                // `Vec` documents `isize::MAX` as its maximum allocation size.
+                // `self.buf.len() < isize::MAX` because `self.buf` is a `Vec`
+                 //and `Vec` documents `isize::MAX` as its maximum allocation
+                //size.
                 Some(index + offset)
             } else {
                 buf.find(needle)
             }
         }
-        // convert to a concrete type and delegate to a single `index` impl
-        // to minimize code duplication when monomorphizing.
+        // convert to a concrete type and delegate to a single `index` impl to
+         //minimize code duplication when monomorphizing.
         let needle = needle.as_ref();
         inner(self.inner.as_slice(), needle, offset)
     }
@@ -1670,8 +1670,8 @@ impl String {
                 buf.rfind(needle)
             }
         }
-        // convert to a concrete type and delegate to a single `rindex` impl
-        // to minimize code duplication when monomorphizing.
+        // convert to a concrete type and delegate to a single `rindex` impl to
+         //minimize code duplication when monomorphizing.
         let needle = needle.as_ref();
         inner(self.inner.as_slice(), needle, offset)
     }
@@ -2034,8 +2034,8 @@ fn chomp(string: &mut String, separator: Option<&[u8]>) -> bool {
         }
         Some(separator) if string.inner.ends_with(separator) => {
             let original_len = string.len();
-            // This subtraction is guaranteed not to panic because
-            // `separator` is a substring of `buf`.
+            // This subtraction is guaranteed not to panic because `separator` is
+             //a substring of `buf`.
             let truncate_to_len = original_len - separator.len();
             string.inner.truncate(truncate_to_len);
             // Separator is non-empty and we are always truncating, so this
diff --git i/spinoso-symbol/src/casecmp/unicode.rs w/spinoso-symbol/src/casecmp/unicode.rs
index 2f0c404344..ed73820655 100644
--- i/spinoso-symbol/src/casecmp/unicode.rs
+++ w/spinoso-symbol/src/casecmp/unicode.rs
@@ -49,9 +49,9 @@ where
         // Encoding mismatch, the bytes are not comparable using Unicode case
         // folding.
         //
-        // > `nil` is returned if the two symbols have incompatible encodings,
-        // > or if `other_symbol` is not a symbol.
-        // > <https://ruby-doc.org/core-3.1.2/Symbol.html#method-i-casecmp-3F>
+        // > `nil` is returned if the two symbols have incompatible encodings, > or
+           //if `other_symbol` is not a symbol. >
+        //<https://ruby-doc.org/core-3.1.2/Symbol.html#method-i-casecmp-3F>
         (Ok(_), Err(_)) | (Err(_), Ok(_)) => return Ok(None),
     };
     Ok(Some(cmp))
diff --git i/spinoso-symbol/src/ident.rs w/spinoso-symbol/src/ident.rs
index a88a8eec33..087c3147ea 100644
--- i/spinoso-symbol/src/ident.rs
+++ w/spinoso-symbol/src/ident.rs
@@ -322,7 +322,8 @@ impl TryFrom<&[u8]> for IdentifierType {
     }
 }

-/// Error type returned from the [`FromStr`] implementation on [`IdentifierType`].
+/// Error type returned from the [`FromStr`] implementation on
+/// [`IdentifierType`].
 ///
 /// # Examples
 ///
@@ -504,8 +505,8 @@ fn is_ident_char(ch: char) -> bool {
 /// Scan the [`char`]s in the input until either invalid UTF-8 or an invalid
 /// ident is found. See [`is_ident_char`].
 ///
-/// This method returns `Some(index)` of the start of the first invalid ident
-/// or `None` if the whole input is a valid ident.
+/// This method returns `Some(index)` of the start of the first invalid ident or
+/// `None` if the whole input is a valid ident.
 ///
 /// Empty slices are not valid idents.
 #[inline]
diff --git i/spinoso-symbol/src/inspect.rs w/spinoso-symbol/src/inspect.rs
index ef056ac623..72a7b3fa6f 100644
--- i/spinoso-symbol/src/inspect.rs
+++ w/spinoso-symbol/src/inspect.rs
@@ -91,9 +91,9 @@ impl<'a> Inspect<'a> {
     /// representation of the interned byte slice associated with the symbol in
     /// the underlying interner.
     ///
-    /// This formatter writes content like `:spinoso` and `:"invalid-\xFF-utf8"`.
-    /// To see example output of the underlying iterator, see the `Inspect`
-    /// documentation.
+    /// This formatter writes content like `:spinoso` and
+    /// `:"invalid-\xFF-utf8"`. To see example output of the underlying
+    /// iterator, see the `Inspect` documentation.
     ///
     /// To write binary output, use [`write_into`], which requires the **std**
     /// feature to be activated.
@@ -135,9 +135,9 @@ impl<'a> Inspect<'a> {
     /// representation of the interned byte slice associated with the symbol in
     /// the underlying interner.
     ///
-    /// This formatter writes content like `:spinoso` and `:"invalid-\xFF-utf8"`.
-    /// To see example output of the underlying iterator, see the `Inspect`
-    /// documentation.
+    /// This formatter writes content like `:spinoso` and
+    /// `:"invalid-\xFF-utf8"`. To see example output of the underlying
+    /// iterator, see the `Inspect` documentation.
     ///
     /// To write to a [formatter], use [`format_into`].
     ///
diff --git i/spinoso-symbol/src/lib.rs w/spinoso-symbol/src/lib.rs
index 969f76caa4..18e3731284 100644
--- i/spinoso-symbol/src/lib.rs
+++ w/spinoso-symbol/src/lib.rs
@@ -157,8 +157,8 @@ impl std::error::Error for SymbolOverflowError {}

 /// Identifier bound to an interned byte string.
 ///
-/// A `Symbol` allows retrieving a reference to the original interned
-/// byte string. Equivalent `Symbol`s will resolve to an identical byte string.
+/// A `Symbol` allows retrieving a reference to the original interned byte
+/// string. Equivalent `Symbol`s will resolve to an identical byte string.
 ///
 /// `Symbol`s are based on a `u32` index. They are cheap to compare and cheap to
 /// copy.
@@ -176,11 +176,11 @@ impl Borrow<u32> for Symbol {
 impl Symbol {
     /// Construct a new `Symbol` from the given `u32`.
     ///
-    /// `Symbol`s constructed manually may fail to resolve to an underlying
-    /// byte string.
+    /// `Symbol`s constructed manually may fail to resolve to an underlying byte
+    /// string.
     ///
-    /// `Symbol`s are not constrained to the interner which created them.
-    /// No runtime checks ensure that the underlying interner is called with a
+    /// `Symbol`s are not constrained to the interner which created them. No
+    /// runtime checks ensure that the underlying interner is called with a
     /// `Symbol` that the interner itself issued.
     ///
     /// # Examples
diff --git i/spinoso-time/src/time/tzrs/convert.rs w/spinoso-time/src/time/tzrs/convert.rs
index 6874b2cc37..3ef023eed3 100644
--- i/spinoso-time/src/time/tzrs/convert.rs
+++ w/spinoso-time/src/time/tzrs/convert.rs
@@ -37,8 +37,8 @@ impl fmt::Display for Time {
 impl Time {
     /// Formats _time_ according to the directives in the given format string.
     ///
-    /// Can be used to implement [`Time#strftime`]. The resulting string should be
-    /// treated as an ASCII-encoded string.
+    /// Can be used to implement [`Time#strftime`]. The resulting string should
+    /// be treated as an ASCII-encoded string.
     ///
     /// # Examples
     ///
diff --git i/spinoso-time/src/time/tzrs/error.rs w/spinoso-time/src/time/tzrs/error.rs
index 7473f43ccd..3f36c7928d 100644
--- i/spinoso-time/src/time/tzrs/error.rs
+++ w/spinoso-time/src/time/tzrs/error.rs
@@ -22,8 +22,8 @@ pub enum TimeError {
     /// Note: [`tz::error::DateTimeError`] is only thrown from `tz-rs` when a
     /// provided component value is out of range.
     ///
-    /// Note: This is different from how MRI ruby is implemented. e.g. Second
-    /// 60 is valid in MRI, and will just add an additional second instead of
+    /// Note: This is different from how MRI ruby is implemented. e.g. Second 60
+    /// is valid in MRI, and will just add an additional second instead of
     /// erroring.
     ComponentOutOfRangeError(DateTimeError),

@@ -103,8 +103,8 @@ impl From<TzError> for TimeError {
         // Allowing matching arms due to documentation
         #[allow(clippy::match_same_arms)]
         match error {
-            // These two are generally recoverable within the usable of `spinoso_time`
-            // TzError::DateTimeError(error) => Self::from(error),
+            // These two are generally recoverable within the usable of
+             //`spinoso_time` TzError::DateTimeError(error) => Self::from(error),
             TzError::ProjectDateTimeError(error) => Self::from(error),

             // The rest will bleed through, but are included here for reference
diff --git i/spinoso-time/src/time/tzrs/math.rs w/spinoso-time/src/time/tzrs/math.rs
index bfc2433c44..76de1f99e4 100644
--- i/spinoso-time/src/time/tzrs/math.rs
+++ w/spinoso-time/src/time/tzrs/math.rs
@@ -74,7 +74,8 @@ impl Time {
                     new_nanos -= NANOS_IN_SECOND;
                 }

-                // Rounding should never cause an error generating a new time since it's always a truncation
+                // Rounding should never cause an error generating a new time
+                 //since it's always a truncation
                 let dt = DateTime::from_timespec_and_local(unix_time, new_nanos, local_time_type)
                     .expect("Could not round the datetime");
                 Self {
@@ -171,8 +172,8 @@ impl Time {

 // Subtraction
 impl Time {
-    /// Subtraction — Subtracts the given duration from _time_ and returns
-    /// that value as a new `Time` object.
+    /// Subtraction — Subtracts the given duration from _time_ and returns that
+    /// value as a new `Time` object.
     ///
     /// # Errors
     ///
diff --git i/spinoso-time/src/time/tzrs/mod.rs w/spinoso-time/src/time/tzrs/mod.rs
index 44582c9f6c..82f03c6cdd 100644
--- i/spinoso-time/src/time/tzrs/mod.rs
+++ w/spinoso-time/src/time/tzrs/mod.rs
@@ -141,7 +141,8 @@ impl Time {
     ///
     /// # Errors
     ///
-    /// Can produce a [`TimeError`], generally when provided values are out of range.
+    /// Can produce a [`TimeError`], generally when provided values are out of
+    /// range.
     ///
     /// [`Time#new`]: https://ruby-doc.org/core-3.1.2/Time.html#method-c-new
     /// [`Timezone`]: https://ruby-doc.org/core-3.1.2/Time.html#class-Time-label-Timezone+argument
@@ -175,7 +176,8 @@ impl Time {
         // upstream has provided a test case which means we have a test that
         // simulates this failure condition and requires us to handle it.
         //
-        // See: https://github.com/x-hgg-x/tz-rs/issues/34#issuecomment-1206140198
+        // See:
+         //https://github.com/x-hgg-x/tz-rs/issues/34#issuecomment-1206140198
         let dt = found_date_times.latest().ok_or(TimeError::Unknown)?;
         Ok(Self { inner: dt, offset })
     }
@@ -197,7 +199,8 @@ impl Time {
     ///
     /// # Errors
     ///
-    /// Can produce a [`TimeError`], however these should never been seen in regular usage.
+    /// Can produce a [`TimeError`], however these should never been seen in
+    /// regular usage.
     ///
     /// [`Time#now`]: https://ruby-doc.org/core-3.1.2/Time.html#method-c-now
     #[inline]
@@ -228,7 +231,8 @@ impl Time {
     ///
     /// # Errors
     ///
-    /// Can produce a [`TimeError`], however these should not be seen during regular usage.
+    /// Can produce a [`TimeError`], however these should not be seen during
+    /// regular usage.
     ///
     /// [`Time#at`]: https://ruby-doc.org/core-3.1.2/Time.html#method-c-at
     #[inline]
@@ -264,7 +268,8 @@ impl TryFrom<ToA> for Time {
     ///
     /// # Errors
     ///
-    /// Can produce a [`TimeError`], generally when provided values are out of range.
+    /// Can produce a [`TimeError`], generally when provided values are out of
+    /// range.
     #[inline]
     fn try_from(to_a: ToA) -> Result<Self> {
         let offset = Offset::try_from(to_a.zone).unwrap_or_else(|_| Offset::utc());
diff --git i/spinoso-time/src/time/tzrs/offset.rs w/spinoso-time/src/time/tzrs/offset.rs
index 13b77bfc30..5290f2497e 100644
--- i/spinoso-time/src/time/tzrs/offset.rs
+++ w/spinoso-time/src/time/tzrs/offset.rs
@@ -61,8 +61,8 @@ fn local_time_zone() -> TimeZoneRef<'static> {
     GMT
 }

-/// Generates a [+/-]HHMM timezone format from a given number of seconds
-/// Note: the actual seconds element is effectively ignored here
+/// Generates a [+/-]HHMM timezone format from a given number of seconds Note:
+/// the actual seconds element is effectively ignored here
 #[inline]
 #[must_use]
 fn offset_hhmm_from_seconds(seconds: i32) -> String {
@@ -311,8 +311,8 @@ impl TryFrom<&str> for Offset {
                 // includes all sorts of numerals, including Devanagari and
                 // Kannada, which don't parse into an `i32` using `FromStr`.
                 //
-                // `[[:digit:]]` is documented to be an ASCII character class
-                // for only digits 0-9.
+                // `[[:digit:]]` is documented to be an ASCII character class for
+                 //only digits 0-9.
                 //
                 // See:
                 // - https://docs.rs/regex/latest/regex/#perl-character-classes-unicode-friendly
diff --git i/spinoso-time/src/time/tzrs/parts.rs w/spinoso-time/src/time/tzrs/parts.rs
index e02a8138a7..33a0d515e7 100644
--- i/spinoso-time/src/time/tzrs/parts.rs
+++ w/spinoso-time/src/time/tzrs/parts.rs
@@ -60,8 +60,9 @@ impl Time {

     /// Returns the second of the minute (0..60) for _time_.
     ///
-    /// Seconds range from zero to 60 to allow the system to inject [leap
-    /// seconds].
+    /// Seconds range from zero to 60 to allow the system to inject
+    /// [leap
+ seconds].
     ///
     /// Can be used to implement [`Time#sec`].
     ///
@@ -316,8 +317,8 @@ impl Time {
         self.inner.local_time_type().is_dst()
     }

-    /// Returns an integer representing the day of the week, `0..=6`, with Sunday
-    /// == 0.
+    /// Returns an integer representing the day of the week, `0..=6`, with
+    /// Sunday == 0.
     ///
     /// Can be used to implement [`Time#wday`].
     ///
diff --git i/src/bin/airb.rs w/src/bin/airb.rs
index 47d657c252..f142194010 100644
--- i/src/bin/airb.rs
+++ w/src/bin/airb.rs
@@ -11,8 +11,8 @@
 #![warn(unused_qualifications)]
 #![warn(variant_size_differences)]

-//! `airb` is the Artichoke implementation of `irb` and is an interactive Ruby shell
-//! and [REPL][repl].
+//! `airb` is the Artichoke implementation of `irb` and is an interactive Ruby
+//! shell and [REPL][repl].
 //!
 //! `airb` is a readline enabled shell, although it does not persist history.
 //!
diff --git i/src/bin/artichoke.rs w/src/bin/artichoke.rs
index 5aab468a74..2be5d61deb 100644
--- i/src/bin/artichoke.rs
+++ w/src/bin/artichoke.rs
@@ -173,7 +173,7 @@ fn command() -> Command<'static> {
 //
 // `ripgrep` is licensed with the MIT License Copyright (c) 2015 Andrew Gallant.
 //
-// https://github.com/BurntSushi/ripgrep/blob/9f924ee187d4c62aa6ebe4903d0cfc6507a5adb5/LICENSE-MIT
+//  //https://github.com/BurntSushi/ripgrep/blob/9f924ee187d4c62aa6ebe4903d0cfc6507a5adb5/LICENSE-MIT
 //
 // See https://github.com/artichoke/artichoke/issues/1301.

@@ -195,12 +195,12 @@ where
     if err.use_stderr() {
         return Err(err.into());
     }
-    // Explicitly ignore any error returned by write!. The most likely error
-    // at this point is a broken pipe error, in which case, we want to ignore
-    // it and exit quietly.
+    // Explicitly ignore any error returned by write!. The most likely error at
+     //this point is a broken pipe error, in which case, we want to ignore it and
+    //exit quietly.
     //
-    // (This is the point of this helper function. clap's functionality for
-    // doing this will panic on a broken pipe error.)
+    // (This is the point of this helper function. clap's functionality for doing
+     //this will panic on a broken pipe error.)
     let _ignored = write!(io::stdout(), "{}", err);
     process::exit(0);
 }
diff --git i/src/lib.rs w/src/lib.rs
index 1c574a3a75..27657f0b4a 100644
--- i/src/lib.rs
+++ w/src/lib.rs
@@ -13,9 +13,11 @@

 //! Artichoke Ruby
 //!
-//! This crate is a Rust and Ruby implementation of the [Ruby programming
-//! language][rubylang]. Artichoke is not production-ready, but intends to be a
-//! [MRI-compliant][rubyspec] implementation of [recent MRI Ruby][mri-target].
+//! This crate is a Rust and Ruby implementation of the
+//! [Ruby programming
+ language][rubylang]. Artichoke is not production-ready,
+//! but intends to be a [MRI-compliant][rubyspec] implementation of
+//! [recent MRI Ruby][mri-target].
 //!
 //! [mri-target]: https://github.com/artichoke/artichoke/blob/trunk/RUBYSPEC.md#mri-target
 //!
diff --git i/src/parser.rs w/src/parser.rs
index c25cc27df2..f9eb79b410 100644
--- i/src/parser.rs
+++ w/src/parser.rs
@@ -193,8 +193,8 @@ impl<'a> Parser<'a> {
                 EXPR_ENDFN => false,
                 // jump keyword like break, return, ...
                 EXPR_MID => false,
-                // this token is unreachable and is used to do integer math on the
-                // values of `mrb_lex_state_enum`.
+                // this token is unreachable and is used to do integer math on
+                 //the values of `mrb_lex_state_enum`.
                 EXPR_MAX_STATE => false,
             };
             if code_has_unterminated_expression {
@@ -216,7 +216,7 @@ impl<'a> Drop for Parser<'a> {
                 sys::mrb_parser_free(parser.as_mut());
             });
         }
-        // There is no need to free `context` since it is owned by the
-        // Artichoke state.
+        // There is no need to free `context` since it is owned by the Artichoke
+         //state.
     }
 }
diff --git i/src/ruby.rs w/src/ruby.rs
index a5710565d5..41a9d67279 100644
--- i/src/ruby.rs
+++ w/src/ruby.rs
@@ -219,9 +219,9 @@ fn load_error<P: AsRef<OsStr>>(file: P, message: &str) -> Result<String, Error>
 // This function exists to provide a workaround for Artichoke not being able to
 // read from the local file system.
 //
-// By passing the `--with-fixture PATH` argument, this function loads the file
-// at `PATH` into memory and stores it in the interpreter bound to the
-// `$fixture` global.
+// By passing the `--with-fixture PATH` argument, this function loads the file at
+ //`PATH` into memory and stores it in the interpreter bound to the `$fixture`
+//global.
 #[inline]
 fn setup_fixture_hack<P: AsRef<Path>>(interp: &mut Artichoke, fixture: P) -> Result<(), Error> {
     let data = if let Ok(data) = fs::read(fixture.as_ref()) {

as an aside it looks like grapheme cluster emojis are reflowed differently than prettier does. Maybe cargo-spellcheck is counting these as multiple characters?

this reflow is also broken:
diff --git i/spinoso-time/src/time/tzrs/parts.rs w/spinoso-time/src/time/tzrs/parts.rs
index e02a8138a7..33a0d515e7 100644
--- i/spinoso-time/src/time/tzrs/parts.rs
+++ w/spinoso-time/src/time/tzrs/parts.rs
@@ -60,8 +60,9 @@ impl Time {

     /// Returns the second of the minute (0..60) for _time_.
     ///
-    /// Seconds range from zero to 60 to allow the system to inject [leap
-    /// seconds].
+    /// Seconds range from zero to 60 to allow the system to inject
+    /// [leap
+ seconds].
     ///
     /// Can be used to implement [`Time#sec`].
     ///
@@ -316,8 +317,8 @@ impl Time {
         self.inner.local_time_type().is_dst()
     }

-    /// Returns an integer representing the day of the week, `0..=6`, with Sunday
-    /// == 0.
+    /// Returns an integer representing the day of the week, `0..=6`, with
+    /// Sunday == 0.
     ///
     /// Can be used to implement [`Time#wday`].
     ///

block quotes in // comments appear to be reflowed incorrectly as well

Graphemes are not handled, I didn't figure out a way to reliably count their length. See #143