This sub in a nutshell

There’s so many because each of those is a combination of a given character encoding and ownership. * String/str -> known-length UTF-8 * CString/CStr -> the way C does it (null-terminated ASCII) * OsString/OsStr -> the way your OS does it (UTF-8 for Unix, UTF-16 for Windows) Ownership: * &str/&[…]Str -> Reference to a string owned by someone else. I can’t delete it or change it. * &mut str/&mut […]Str -> Mutable reference to a string owned by someone else. They’ve allowed me to change its contents, but not delete it or change its length. * […]String -> Owned by me. I can change it’s contents and delete it whenever I want. I can give other code references to it. Then there’s those other three that are kinda strings, but really just used more when dealing with encoding/serialization stuff: * Vec<u8> -> Vector of unsigned bytes. Similar to std::vector<char> in C++. Has conversions to and from other owned string types. * [u8; N] -> N-length array of unsigned bytes. * &[u8] -> Slice of unsigned bytes, which is a reference to some array of unsigned bytes. It could be just part of a larger array (hence the name “slice”). Has conversions to from other non-owning string types. By the way, the bit about slices also applies to the other reference string types. They could also be slices of larger strings. PathBuf/&Path are like OsString/&OsStr but with methods to enable easily working with paths. You can push and pop directories and file names, and they’ll handle representing that as an OS-appropriate path. Box, Rc, and Arc are owning pointer types used for allocation. Box is the simplest: it uniquely owns its contents. This is like most owning types in rust. Rc is a reference-counted shared pointer. Ownership can be shared by cloning the Rc, which increments a counter tracking the number of references. When someone is done with the Rc, the decrement the counter. If they find it to be zero, they know that they were the last owner of the Rc, so they go ahead and actually delete the data it owned. Arc is Rc, but the counter is atomic so that cloning is safe with multiple threads. Box, Rc, and Arc have generally immutable content, with extra methods to acquire it mutably if possible. It’s always possible for Box, and possible for Rc and Arc as long as there are no other remaining references to the same content. Cow<‘static, str> is a clone-on-write reference to a statically-allocated string. As long as I don’t need to change the underlying string, the reference points to same statically-allocated content. I’m allowed to change it though (it’s an owning reference), and if I do, the Cow will clone the static string into a new allocation so that I don’t affect the original. So yeah, definitely not that bad. (i’m going entirely off of memory here so this might not be 100% accurate)