Mara Bos Profile picture
Apr 22, 2021 β€’ 17 tweets β€’ 6 min read β€’ Read on X
Lots of new standard library additions will become stable in @rustlang 1.53. πŸ¦€πŸŽ‰

Thread:
1. Duration::ZERO, Duration::is_zero(), Duration::MAX pub const ZERO: Duration  A...
2. Duration::saturating_{add,sub,mul}

Since Durations cannot represent negative values, saturating_sub might come in handy to avoid panics. pub fn saturating_add(self,...pub fn saturating_sub(self,...
3. Option::insert

`opt.insert(1)` does the same as `opt = Some(1)`, but also gives you a mutable reference to the `1` inside that Some after it's stored in the Option. pub fn insert(&mut self, va...
4. {integer}::BITS

I already promised this one for Rust 1.51, but we had to temporarily revert it. Trying again now for 1.53 :)

5. BufReader::seek_relative

Unlike the seek() function from the Seek trait, this one does not return the current position in the stream, which allows the BufReader to perform the seek without accessing the underlying reader if the new position lies within the buffer. impl<R: Seek> BufReader<R> ...
6. NonZero*::leading_zeros() and NonZero*::trailing_zeros()

These avoid the zero-check that the same functions on the regular integer types need to do, since on many architectures, the corresponding native instruction doesn't handle the zero case.

These are both `const fn`s. pub const fn leading_zeros(...
7. std::array::from_ref and std::array::from_mut

These can safely convert a &T to &[T; 1] or &mut T to &mut [T; 1]. Function std::array::from_r...
8. f32::is_subnormal and f64::is_subnormal

A way to easily check if a floating point number is subnormal. pub fn is_subnormal(self) -...
9. DebugStruct::finish_non_exhaustive()

This allows you to mark the custom Debug representation of your type with fmt.debug_struct() to not be exhaustive. It adds two dots before the closing brace.

We've also updated the std types' Debug impls to consistently use this. pub fn finish_non_exhaustiv...
10. AtomicPtr::fetch_update and AtomicBool::fetch_update

We already had this one on the other atomic types, but they were missing on atomic pointers and booleans. pub fn fetch_update<F>(    ...
11. Peekable::peek_mut()

This allows you to mutate the peeked value which will be returned next by the Iterator. pub fn peek_mut(&mut self) ...
12. OsStr::{make_ascii_lowercase, make_ascii_uppercase, to_ascii_lowercase, to_ascii_uppercase}

We already had these on `str`s, but these new ones can be applied to an OsStr directly even if it's not valid UTF-8. pub fn make_ascii_lowercase...
13. std::cmp::{min_by, max_by, min_by_key, max_by_key}

Like `std::cmp::{min, max}`, but allows you to specify the way the values are compared. Function std::cmp::min_by_k...
14. io::ErrorKind::Unsupported

A new ErrorKind which is used when the operation is not supported by the system. (E.g. ENOSYS on Unix and ERROR_CALL_NOT_IMPLEMENTED on Windows.)

Previously these fell under io::ErrorKind::Other. Unsupported  This operation...
15. BTreeMap::retain and BTreeSet::retain

Just like Vec::retain, these allow you to filter out some entries from the collection based on a predicate.

In case of the BTreeMap, you get access to both the key and the value, and can mutate the values if needed. pub fn retain<F>(&mut self,...
And that's the end of this thread. :)

Thanks to everyone involved in the design, implementation and stabilization of all these features! πŸ’›

I probably missed a few stabilizations, and there will be even more since Rust 1.53 is still under development. So stay tuned. πŸ™‚

β€’ β€’ β€’

Missing some Tweet in this thread? You can try to force a refresh
γ€€

Keep Current with Mara Bos

Mara Bos Profile picture

Stay in touch and get notified when new unrolls are available from this author!

Read all threads

This Thread may be Removed Anytime!

PDF

Twitter may remove this content at anytime! Save it as PDF for later use!

Try unrolling a thread yourself!

how to unroll video
  1. Follow @ThreadReaderApp to mention us!

  2. From a Twitter thread mention us with a keyword "unroll"
@threadreaderapp unroll

Practice here first or read more on our help page!

More from @m_ou_se

Dec 15, 2022
πŸ†•πŸ¦€ Just an hour ago, #rustlang 1.66.0 was released!

As usual, here's a thread with some of the highlights. 🧡

1/12
Rust 1.66 comes with std::hint::black_box(), a function that does nothing. However, the compiler tries its very best to pretend it doesn't know what it does.

It is useful in benchmarks, to prevent the compiler from optimizing your entire benchmark away.

2/12 use std::hint::black_box; use std::sync::atomic::{AtomicU64,
The Option type got a new method: Option::unzip(). It's basically the opposite of Option::zip(): it splits an Option of a pair into a pair of Options.

3/12 impl<T, U> Option<(T, U)>  pub fn unzip(self) -> (Option<T>,
Read 12 tweets
Nov 3, 2022
πŸ†•πŸ¦€ About an hour ago, @rustlang 1.65.0 was released.

As is tradition, here's a thread with some of the highlights. 🧡

1/10
Today's Rust release contains a long-awaited feature: generic associated types (GATs). πŸŽ‰

This allows associated types to be generic, which unlocks a lot of useful patterns.

See the blog post about the stabilization of this feature for details: blog.rust-lang.org/2022/10/28/gat…

2/10 trait LendingIterator {     type Item<'a> where Self: 'a;
Another big new feature in today's Rust release is let-else statements.

You can now write things like:

let Ok(a) = i32::from_str("123") else { return };

without needing an if or match statement. This can be useful to avoid deeply nested if statements.

3/10 fn parse_key_value(s: &str) -> Result<(&str, i32), ParseErro
Read 10 tweets
Sep 22, 2022
πŸ†•πŸ¦€ A few hours ago, @rustlang 1.64.0 was released! πŸŽ‰

Just like every six weeks, at every new release, here's a thread with some of the highlights. 🧡

1/15

blog.rust-lang.org/2022/09/22/Rus…
Rust now has a new async-related trait: IntoFuture.

The .await syntax be used on anything that implements IntoFuture. (Similar to how, with a for loop, you can iterate over anything that implements IntoIterator.)

This allows types to provide easier async interfaces.

2/15 use std::future::{ready, In...
Today's Rust release also comes with two more async-related tools:

The std::future::poll_fn function allows you to easily create a future from a closure (like iter::from_fn for iterators).

The std::task::ready!() macro extracts a Poll::Ready, or returns early on Pending.

3/15 let f = future::poll_fn(|cx...
Read 15 tweets
Aug 11, 2022
πŸ†•πŸ¦€ Just moments ago, @rustlang 1.63.0 was released! πŸŽ‰

It's quite a big release, with even more exciting new features than usual!

Here's a thread with some of the highlights. 🧡

1/16

blog.rust-lang.org/2022/08/11/Rus…
One of the features I'm most excited about is scoped threads! (Although I'm obviously biased, since I worked on this myself.)

As of today, you can use std::thread::scope() to spawn threads that borrow local variables, reducing the need for Arc! ✨

doc.rust-lang.org/stable/std/thr…

2/16 let mut a = vec![1, 2, 3]; let mut x = 0;  std::thread::scop
Another thing I'm very excited about, is that Mutex, RwLock and Condvar now all have a _const_ new function.

This means you can now have a static Mutex without having to use lazy_static or once_cell. ✨

3/16 use std::sync::Mutex;  static S: Mutex<String> = Mutex::new(
Read 16 tweets
Jun 30, 2022
πŸ†•πŸ¦€ Just moments ago, @rustlang 1.62.0 was released! πŸŽ‰

As usual, a thread with some of the highlights. 🧡

1/9

blog.rust-lang.org/2022/06/30/Rus…
Cargo now has 'cargo add' built-in: a (sub)command to add a crate to your Cargo.toml. It automatically looks up the latest version, and shows you the available features of the crate.

See `cargo add --help` for more details.

2/9 $ cargo add rand     Updating crates.io index       Adding r
On Linux and several BSDs, std::sync's Mutex, RwLock, and Condvar now no longer do any allocations. They used to be (heap-allocated) wrappers around pthread lock types, but have been replaced by a minimal, more efficient, futex-based implementations.

3/9

Read 9 tweets
May 16, 2022
πŸ¦€ As of Rust 1.62 (going into beta this week), std::sync::Mutex, RwLock, and Condvar no longer do any allocations on Linux. πŸŽ‰

Benchmarking locks is extremely tricky, as their performance depends heavily on the exact use case, but there are very noticable differences: A table showing before and after times of three tests.  test
std's Mutex basically used to contain a Pin<Box<pthread_mutex_t>>, where the pinned Box was only necessary because pthread_mutex_t is not guaranteed movable. The new Mutex no longer uses pthread, and instead directly uses the futex syscall, making it smaller and more efficient.
Also, the new RwLock on Linux prefers writers, which prevents writer starvation. pthread_rwlock_t prefers readers by default, to allow recursive read locking. Rust's RwLock does not make recursion guarantees, and on several platforms (including Windows) already preferred writers.
Read 4 tweets

Did Thread Reader help you today?

Support us! We are indie developers!


This site is made by just two indie developers on a laptop doing marketing, support and development! Read more about the story.

Become a Premium Member ($3/month or $30/year) and get exclusive features!

Become Premium

Don't want to be a Premium member but still want to support us?

Make a small donation by buying us coffee ($5) or help with server cost ($10)

Donate via Paypal

Or Donate anonymously using crypto!

Ethereum

0xfe58350B80634f60Fa6Dc149a72b4DFbc17D341E copy

Bitcoin

3ATGMxNzCUFzxpMCHL5sWSt4DVtS8UqXpi copy

Thank you for your support!

Follow Us!

:(