Share this page!

Enter URL or ID to Unroll

You can paste full URL like: https://x.com/threadreaderapp/status/1644127596119195649
or just the ID like: 1644127596119195649

How to get URL link on X (Twitter) App

  1. On the Twitter thread, click on or icon on the bottom
  2. Click again on or Share Via icon
  3. Click on Copy Link to Tweet
  4. Paste it above and click "Unroll Thread"!
  5. More info at Twitter Help
Mara Bos Profile picture
@m_ou_se
Dec 2, 2021 • 11 tweets • 5 min read • Read on X
Scrolly
🦀✨ @rustlang 1.57.0 was released just moments ago!

blog.rust-lang.org/2021/12/02/Rus…

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 const fn f<T>() { assert!(std::mem::size_of::<T>() < 4);error[E0080]: evaluation of constant value failed --> src/m
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.

(See the full list here: github.com/rust-lang/rust…)

3/11 let mut a: f64 = 180.0; a.to_radians(); // Doesn't change twarning: unused return value of `core::f64::<impl f64>::to_r
3. Iterator::map_while.

Basically a combination of map and take_while: Your closure is used to map each item, but can return None when it's done.

4/11 let a = [1, 2, 3, 4, 0, 5, 6]; let v: Vec<i32> = a .int
4. Custom Cargo profiles!

Next to the standard Cargo profiles such as `release`, you can now define your own profiles with custom settings:

5/11 # Cargo.toml ... [profile.release-with-checks] inherits = $ cargo r --profile=release-with-checks Compiling example
5. A dot or question mark after a braced macro invocation is no longer an error:

m! { .. }.method(); // ok!
m! { .. }?; // ok!

See

6/11
6. Fallible allocation.

Vec, String, VecDeque, HashMap and HashSet now have a .try_reserve() method. This method is similar to .reserve(), except it doesn't panic/abort when it was unable to allocate memory.

7/11 Screenshot of the reference documentation of Vec::try_reserv
7. Vec::leak no longer reallocates.

Vec::leak used to shrink the capacity before leaking the data, which might involve a reallocation. The behaviour is now changed to always leak the current allocation, without shrinking/reallocating first.

8/11 Screenshot of the documentation of Vec::leak, with one parag
8. std::hint::unreachable_unchecked is now const.

In *const* context, it'll result in a compiler error when reached, not in undefined behaviour like it would at runtime.

9/11 const unsafe fn unwrap_unchecked(opt: Option<i32>) -> i32 {
9. There's a few new tier 3 targets:

- armv6k-nintendo-3ds
- armv7-unknown-linux-uclibceabihf
- m68k-unknown-linux-gnu
- aarch64-kmc-solid_asp3
- armv7a-kmc-solid_asp3-eabi
- armv7a-kmc-solid_asp3-eabihf

See doc.rust-lang.org/nightly/rustc/…

10/11
And that's all I wanted to highlight in this thread!

For a more complete list of changes in Rust 1.57, check the release notes:

Rust: github.com/rust-lang/rust…
Cargo: github.com/rust-lang/carg…
Clippy: github.com/rust-lang/rust…

Enjoy!

11/11

• • •

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

Mara Bos Profile picture
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
Mara Bos Profile picture
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
Mara Bos Profile picture
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
Mara Bos Profile picture
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
Mara Bos Profile picture
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
Mara Bos Profile picture
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!

Send Email!

:(