Moo-ving Data Efficiently: Exploring the Rust Cow

Cow stands for copy-on-write. It is a smart pointer that can hold either a borrowed or an owned value of a type that implements the ToOwned trait. The ToOwned trait allows a type to create an owned version of itself from a borrowed one. For example, a &str can be converted to a String using ToOwned.

Cow is useful when you want to avoid unnecessary cloning or allocation of data that might not need to be mutated. For example, suppose you have a function that takes a slice of integers and returns a new slice with all the negative values replaced by their absolute values. If the input slice does not contain any negative values, you don’t need to create a new slice at all. You can just return the input slice as it is. But if the input slice does contain some negative values, you need to create a new slice and copy the positive values and the absolute values of the negative ones. This is where cow can help you. You can use cow to wrap the input slice and return either a borrowed or an owned slice depending on the situation. Here is how you can implement this function using cow:

use std::borrow::Cow;

fn abs_all(input: &[i32]) -> Cow<[i32]> {
    // Check if the input slice contains any negative values
    if input.iter().any(|&x| x < 0) {
        // If yes, create a new vector with the absolute values
        let mut output = Vec::new();
        for &x in input {
            output.push(x.abs());
        }
        // Return the vector as an owned slice
        Cow::Owned(output)
    } else {
        // If no, return the input slice as a borrowed slice
        Cow::Borrowed(input)
    }
}

This way, you can avoid cloning or allocating a new slice when it is not necessary. You can use the returned cow as if it was a normal slice, thanks to the Deref trait that cow implements. For example, you can iterate over the elements, get the length, or index into the slice using the cow.

Another benefit of cow is that it allows you to mutate the data lazily, only when you need to. For example, suppose you have a function that takes a string and returns a new string with all the vowels replaced by asterisks. If the input string does not contain any vowels, you don’t need to create a new string at all. You can just return the input string as it is. But if the input string does contain some vowels, you need to create a new string and copy the non-vowel characters and the asterisks. This is where cow can help you again. You can use cow to wrap the input string and return either a borrowed or an owned string depending on the situation. Here is how you can implement this function using cow:

use std::borrow::Cow;

fn censor_vowels(input: &str) -> Cow<str> {
    // Check if the input string contains any vowels
    if input.contains(|c| "aeiouAEIOU".contains(c)) {
        // If yes, create a new string with the vowels replaced by asterisks
        let output = input.replace(|c| "aeiouAEIOU".contains(c), "*");
        // Return the string as an owned string
        Cow::Owned(output)
    } else {
        // If no, return the input string as a borrowed string
        Cow::Borrowed(input)
    }
}

This way, you can avoid cloning or allocating a new string when it is not necessary. You can use the returned cow as if it was a normal string, thanks to the Deref trait that cow implements. For example, you can get the length, check if it is empty, or concatenate it with another string using the cow.

But what if you want to mutate the returned cow later? For example, suppose you want to append an exclamation mark to the censored string. You can use the to_mut method of cow to get a mutable reference to an owned value, cloning the data if it was borrowed. For example, you can do something like this:

let mut censored = censor_vowels("Hello world");
censored.to_mut().push('!');
println!("{}", censored); // Prints "H*ll* w*rld!"

This way, you can mutate the data only when you need to, and avoid cloning or allocating it otherwise. You can also use the into_owned method of cow to get an owned value, cloning the data if it was borrowed. For example, you can do something like this:

let censored = censor_vowels("Hello world");
let owned = censored.into_owned();
println!("{}", owned); // Prints "H*ll* w*rld"

This way, you can get an owned value from the cow, regardless of whether it was borrowed or owned.

Cow is a very useful and versatile tool in Rust that can help you write more efficient and elegant code. It can also be used with other types that implement the ToOwned trait, such as slices, arrays, paths, and more. You can also implement the ToOwned trait for your own types and use them with cow. Cow is not only a Rust-specific concept, but also a general technique that can be applied in other domains, such as databases, file systems, and memory management.

I hope this article has given you some insight into what cow is, how it works, and how you can use it in your Rust code. If you want to learn more about cow, you can check out the official documentation¹, the LogRocket blog², or the DEV Community³ for more examples and explanations. Happy coding!