Polish off the docs a bit pre-release.

Author: bodil

CHANGELOG.md

@@ -11,21 +11,28 @@ adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 -   `smartstring` now implements its own boxed string type rather than deferring directly to
     `String`, so it no longer makes assumptions it shouldn't be making about the layout of the
-    `String` struct. This also allows us to organise the boxed struct in a way that will let us rely
-    only on our basic assumption that heap memory is word aligned on both big and little endian
-    architectures. The most immediate consequence of this is that `smartstring` will now compile on
-    32-bit big endian architectures such as `mips`.
+    `String` struct.
+
+    This also allows us to organise the boxed struct in a way that will let us rely only on our
+    basic assumption that heap memory is word aligned on both big and little endian architectures.
+    The most immediate consequence of this is that `smartstring` will now compile on 32-bit big
+    endian architectures such as `mips`.
+
+    We are now also explicitly allocating heap memory aligned for `u16` rather than `u8`, ensuring
+    the assumption about pointer alignment becomes an invariant.
 
     In short: `smartstring` no longer relies on undefined behaviour, and should be safe to use
     anywhere.
 
 -   The above means that the boxed `SmartString` is no longer pointer compatible with `String`, so
-    if you were relying on that despite the documentation telling you not to, you'll really have to
+    if you were relying on that despite the documentation urging you not to, you'll really have to
     stop it now. Converting between `SmartString` and `String` using `From` and `Into` traits is
     still efficient and allocation free.
 
 -   The minimum supported rustc version is now 1.57.0.
 
+-   The `smartstring::validate()` function has been removed, as it's no longer needed.
+
 ## [0.2.10] - 2022-02-20
 
 ### CHANGED

src/lib.rs

@@ -10,7 +10,8 @@
 //! and is generally a little faster, and [`Compact`], which is the same as
 //! [`LazyCompact`] except it will aggressively re-inline any expanded
 //! [`String`]s which become short enough to do so.
-//! [`LazyCompact`] is the default.
+//! [`LazyCompact`] is the default, and what you should be using unless
+//! you care considerably more about heap memory usage than performance.
 //!
 //! ## What Is It For?
 //!
@@ -47,7 +48,7 @@
 //! giving us 24 bytes (on 64-bit architectures) minus one bit to encode our
 //! inline string. It uses 23 bytes to store the string data and the remaining
 //! 7 bits to encode the string's length. When the available space is exceeded,
-//! it swaps itself out with a [`String`] containing its previous
+//! it swaps itself out with a boxed string type containing its previous
 //! contents. Likewise, if the string's length should drop below its inline
 //! capacity again, it deallocates the string and moves its contents inline.
 //!
@@ -90,8 +91,6 @@
 //! | [`proptest`](https://crates.io/crates/proptest) | A strategy for generating [`SmartString`]s from a regular expression. |
 //! | [`serde`](https://crates.io/crates/serde) | [`Serialize`][Serialize] and [`Deserialize`][Deserialize] implementations for [`SmartString`]. |
 //!
-//! [IntoString]: struct.SmartString.html#impl-Into%3CString%3E
-//! [serde]: https://crates.io/crates/serde
 //! [Serialize]: https://docs.rs/serde/latest/serde/trait.Serialize.html
 //! [Deserialize]: https://docs.rs/serde/latest/serde/trait.Deserialize.html
 //! [Arbitrary]: https://docs.rs/arbitrary/latest/arbitrary/trait.Arbitrary.html