The primary reason there are so many ways is the Rust ownership and type system.
String is a ‘normal’ mutable UTF-8 string that is allocated on the heap.
&str is either a slice reference pointing to a part of a string or a string literal in read-only memory.
&[u8] is a reference to slice of bytes (so only capable of ASCII characters).
&[u8; N] is a reference to a fixed size slice reference of bytes where the length is encoded in the type.
Vec<u8> is a mutable array of bytes (the former two are immutable in contrast).
&u8 is a reference to a single byte.
OsString is an owned, mutable platform native string in the platform’s preferred representation (e.g. non-zero byte UTF-8 on Linux, non-zero byte UTF-16 in Windows).
OsStr is a borrowed version of an OsString.
Path is a slice that supports operations like obtaining the root element or file name or check if it is absolute or relative or to check if the the file exists in the file system.
PathBuf is an owned, mutable version of the former one.
CString is an owned representation of a string that should be compatible with C (e.g. null terminated and no zero bytes in between). They are handy if you want to call C libraries from Rust code.
CStr is a borrowed version of CString.
&'staticstr is a string slice reference with a static lifetime and is therefore valid for the duration of the entire program (in contrast to slices of Strings that might get de-allocated at some point).
The String vs. &str split is definitely annoying, but a necessary drawback of Rust’s ownership mechanics (which bring many benefits compared to C in other places).
The others have their specific use-cases (like file paths or C interop). It’s certainly not like you constantly juggle 8 different kinds of strings.
Not necessarily a bad thing. If your method of invocation gives context about its possible use cases. You can make the program more safe because you know it’s being used appropriately. If you’re just passing a pointer around anything could happen to it. So it’s hard to help the programmer not make mistakes
All those are ways of calling string in C? Why are there so many?
The primary reason there are so many ways is the Rust ownership and type system.
Stringis a ‘normal’ mutable UTF-8 string that is allocated on the heap.&stris either a slice reference pointing to a part of a string or a string literal in read-only memory.&[u8]is a reference to slice of bytes (so only capable of ASCII characters).&[u8; N]is a reference to a fixed size slice reference of bytes where the length is encoded in the type.Vec<u8>is a mutable array of bytes (the former two are immutable in contrast).&u8is a reference to a single byte.OsStringis an owned, mutable platform native string in the platform’s preferred representation (e.g. non-zero byte UTF-8 on Linux, non-zero byte UTF-16 in Windows).OsStris a borrowed version of anOsString.Pathis a slice that supports operations like obtaining the root element or file name or check if it is absolute or relative or to check if the the file exists in the file system.PathBufis an owned, mutable version of the former one.CStringis an owned representation of a string that should be compatible with C (e.g. null terminated and no zero bytes in between). They are handy if you want to call C libraries from Rust code.CStris a borrowed version ofCString.&'static stris a string slice reference with a static lifetime and is therefore valid for the duration of the entire program (in contrast to slices ofStrings that might get de-allocated at some point).Good explanation. However,
OsStringis not necessarily valid UTF-8/UTF-16 (in thay case, it could simply beString). The docs describe it pretty well.https://doc.rust-lang.org/std/ffi/struct.OsString.html
I’m not sure this meme really cares to make perfect sense, but I don’t think that’s ever useful…?
A single byte is going to be smaller than a pointer address, so you can just copy the
u8without loss of efficiency.what memory safety does to a mf
In Rust, and I don’t know
Isn’t it a bad thing?
The
Stringvs.&strsplit is definitely annoying, but a necessary drawback of Rust’s ownership mechanics (which bring many benefits compared to C in other places).The others have their specific use-cases (like file paths or C interop). It’s certainly not like you constantly juggle 8 different kinds of strings.
I don’t know, I don’t use Rust
Not necessarily a bad thing. If your method of invocation gives context about its possible use cases. You can make the program more safe because you know it’s being used appropriately. If you’re just passing a pointer around anything could happen to it. So it’s hard to help the programmer not make mistakes