Newly stabilized in the standard library is File::options(). It's identical to OpenOptions::new(), but you don't have to import the OpenOptions type separately from the File type.
3/11
Option and Result now have an unsafe unwrap_unchecked() function. If you're absolutely sure that the Option contains a Some, or the Result contains an Ok, you can use these to unwrap the value while skipping any checks. (Getting this wrong means undefined behaviour though!)
4/11
Path and Metadata now have an is_symlink() method. This saves some typing, as previously this had to be done with std::fs::symlink_metadata(path) followed by metadata.file_type().is_symlink().
5/11
In Rust 1.57, many library functions got the #[must_use] attribute to prevent subtle mistakes. With Rust 1.58, this effort is now completed, and all functions that should have #[must_use] according to the accepted guidelines now have that attribute.
The `Command` api now no longer searches the current working directory on Windows, to match the behaviour on other platforms. This will prevent problems like CVE-2021-3013: cve.org/CVERecord?id=C…
7/11
Many file operations like File::open(), fs::create_dir(), etc. now all work with long paths on Windows. The paths are automatically canonicalized and prefixed by \\?\, which is how extended-length paths are expressed on Windows.
8/11
Const evaluation got a bit more powerful again. You can now dereference pointers in const context. Only *const though, not *mut.
9/11
And the last thing I want to highlight in this thread:
Rustdoc now shows methods from all recursive Deref implementations, instead of only the outermost one. So if your type is Deref<Target = String>, it now not only shows the String methods, but also all the str methods.
10/11
And that's the end of today's thread!
For a more complete list of changes in Rust 1.58, check the release notes:
As usual, a thread to highlight some of the new features:
1/11
1. panic!() and assert!() can now be used in const fns.
Any formatting other than panic!("..") and panic!("{}", some_str) is not accepted though, because formatting is not const (yet!).
2/11
2. Many functions in the standard library have been marked as #[must_use], to warn you when just calling the function without using its result is most likely a mistake.
2. Closures in Rust 2021 will capture only the fields of an object you use, instead of the entire object. This should result in fewer fights with the borrow checker:
We already had str::split and str::splitn, which result in an iterator. But when parsing something simple, you often want to split something exactly once. For example, to parse a string containing `key=value`.
2/10
Another one I'm excited about is one of the first features I worked on: std::fmt::Arguments::as_str()
fmt::Arguments is returned by format_args!(), and appears in macros that support formatting.
as_str() allows handling the literal case without special-casing your macro:
I just approved the PR for a very exciting addition to @rustlang 1.53: IntoIterator for arrays 🎉🦀
Before this change, only references to arrays implemented IntoIterator, which meant you could iterate over &[1,2,3] and &mut [1,2,3], but not over [1,2,3] directly.
1/6
The reason we didn't add it sooner was backwards compatibility. `array.into_iter()` already compiles today, because of the way methods get resolved in Rust. This implicitly calls `(&array).into_iter()`. Adding the trait implementation would change the meaning and break code.
2/6
Technically we consider this type of breakage (adding a trait impl) 'minor' and acceptable. But there was too much code that would be broken by it. Thanks to @LukasKalbertodt, such code results in a warning nowadays, but there's a lot of code that just doesn't get updated.