History: When Rust's standard library introduced Cow (Clone-on-Write), the goal was to abstract over data that might be borrowed or owned without forcing immediate allocation. The Clone trait was initially considered, but it only permits producing an identical copy of the same type. For borrowed data like &str, cloning produces another reference rather than the owning String required for mutation. The ToOwned trait was designed specifically to express the relationship between borrowed and owned forms through its associated Owned type.
Problem: If Cow relied on Clone, converting a Cow::Borrowed(&str) to an owned representation for modification would require external conversion logic. Clone lacks the type-level mechanism to transform &str into String, forcing either premature allocation at construction time or complex manual state management. This would violate Cow's zero-cost abstraction principle by making it impossible to defer heap allocation until mutation is actually necessary.
Solution: ToOwned defines type Owned and fn to_owned(&self) -> Self::Owned, allowing &str to specify Owned = String. This enables Cow::to_mut() to lazily allocate only when mutation is requested. If the Cow is already Owned, it returns a mutable reference to the existing data without allocation. The following example demonstrates this efficiency:
use std::borrow::Cow; fn normalize_whitespace(input: &str) -> Cow<'_, str> { if input.contains(" ") { let cleaned = input.replace(" ", " "); Cow::Owned(cleaned) // Allocates only here } else { Cow::Borrowed(input) // Zero-cost borrow } }
A high-throughput log processing service needed to normalize timestamps in entries sourced from memory-mapped files. The input arrived as &str slices pointing into the map, but roughly 10% of entries required timezone adjustments necessitating String allocation. The initial implementation used a custom enum with String and &str variants, requiring exhaustive pattern matching at every access point and manual clone logic that was error-prone and verbose.
Alternative 1: Eager conversion to String. The team considered converting all inputs to String immediately upon ingestion. This approach simplified the data model and eliminated lifetime concerns, but it imposed severe memory overhead. During peak loads, this doubled memory usage for the 90% of logs that never required modification, causing OOM errors when processing 10GB files.
Alternative 2: Using Arc<str> with copy-on-write. Another option involved Arc<str> for immutable sharing combined with Arc::make_mut for modifications. While this provided shared ownership semantics, it introduced atomic reference counting overhead for every access. Additionally, it still required explicit logic to handle the transition from shared to mutable, complicating the borrowing model without providing the desired ergonomics.
Alternative 3: Adopting Cow<'_, str>. The team chose Cow to abstract over the two states. Borrowed variants pointed directly into the memory map with no allocation, while Owned variants held modified strings. This solution was selected because to_mut() deferred allocation until the first mutation occurred, preserving zero-cost for read-only paths while offering a unified API.
Result: The parser maintained high throughput, handling 10GB log files with only 200MB of actual heap allocations. By leveraging Cow, the system eliminated manual state tracking, maintained Send and Sync properties for parallel processing, and reduced code complexity by 60% compared to the custom enum approach.
into_owned returns ToOwned::Owned by value, which requires a compile-time known size to allocate stack space. While Cow can wrap unsized types like str via Cow<'_, str>, the Owned type (String) is sized. Candidates often confuse Cow<'_, T> with Cow<'_, &T>, attempting to implement traits for the reference rather than the borrowed type. Without the Sized bound on ToOwned::Owned, the compiler could not construct the return value for into_owned, as it would attempt to return an unsized str directly rather than the sized String container.
Cow implements Borrow<Borrowed> where Borrowed: ToOwned, allowing Cow<String> to be looked up with &str. However, Borrow imposes a strict contract: if two values are equal via Eq, they must produce identical hash values. Candidates often implement custom PartialEq for Cow (e.g., case-insensitive comparison) while retaining the standard Hash implementation. This violates the contract because two Cow values might compare equal under custom logic but hash differently if the Hash implementation sees the original bytes. This leads to HashMap lookup failures where a key appears to exist but cannot be found.
To construct a Borrowed variant, Cow requires a reference &'a B with lifetime 'a. A blanket Default implementation would need to produce a reference valid for 'static (e.g., &'static str for ""), but &str itself does not implement Default because there is no universal reference value to return. Candidates often suggest defaulting to Cow::Borrowed(""), but this requires either a 'static lifetime bound on B or specialization not available in stable Rust. Consequently, the standard library requires ToOwned::Owned: Default, forcing Cow::Owned(String::new()) (an allocation) even for empty default values. Candidates miss this distinction because they confuse the availability of string literals in specific scopes with a general Default implementation for references.