Software Update: Rest 1.35.0

Rust is a programming language created by Graydon Hoare and originally developed by Mozilla. It is partly inspired by the C programming language, but has syntactic and semantic differences. It focuses on security and aims to use modern computer systems more efficiently. It will be deployed by Cloudflare, OVH, Mozilla, Deliveroo, Coursera, AppSignal and Threema, among others. Version 1.35.0 was recently released with the following announcement:

Announcing Rest 1.35.0

The Rust team is happy to announce a new version of Rust, 1.35.0. Rust is a programming language that is empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, getting Rust 1.35.0 is as easy as:
$ rustup update stable
If you don’t have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.35.0 on GitHub.

What’s in 1.35.0 stable

The highlight of this release is the implementation of the FnOnce, FnMut, and Fn closure traits for Box

Fn* closure traits implemented for Box
In Rust 1.35.0, the FnOnce, FnMut, and the Fn traits are now implemented for Box

The following code now works:
fn foo(x: Box

Furthermore, you can now directly call Box

Coercing closures to unsafe fn pointers
Since Rust 1.19.0, it has been possible to coerce closures that do not capture from their environment into function pointers. For example, you may write:
fn twice(x: u8, f: fn(u8) -> u8) -> u8 {
f(f(x))
}

fn main() {
assert_eq!(42, twice(0, |x| x + 21));
}

This has however not extended to unsafe function pointers. With this release of Rust, you may now do so. For example:
/// The safety invariants are those of the `unsafe fn` pointer passed.
unsafe fn call_unsafe_fn_ptr(f: unsafe fn()) {
f()
}

fn main() {
// SAFETY: There are no invariants.
// The closure is statically prevented from doing unsafe things.
unsafe {
call_unsafe_fn_ptr(|| {
dbg!();
});
}
}

Calling dbg!() with no argument
For the benefit of all the occasional and frequent “print debuggers” out there, Rust 1.32.0 saw the release of the dbg! macro. To recap, the macro allows you to quickly inspect the value of some expression with context. For example, when running:
fn main() {
note mut x = 0;

if dbg!(x == 1) {
x += 1;
}

dbg!(x);
}

…you would see:
[src/main.rs:4] x == 1 = false
[src/main.rs:8] x = 0

As seen in the previous section, where the higher order function call_unsafe_fn_ptr is called, you may now also call dbg! without passing any arguments. This is useful when tracing what branches your application takes. For example, with:
fn main() {
let condition = true;

if condition {
dbg!();
}
}

…you would see:
src/main.rs:5]

Library stabilizations
In 1.35.0, a number of APIs have become stable. In addition, some implementations were added and other changes occurred as well. See the detailed release notes for more details.

Copy the sign of a floating point number onto another
With this release, new methods copysign have been added to the floating point primitive types f32 and f64:

• f32::copysign
• f64::copysign

As the name suggests, you can use these to copy the sign of one number onto another. For example:
fn main() {
assert_eq!(3.5_f32.copysign(-0.42), -3.5);
}

Check whether a Range contains a value
Rust 1.35.0 contains a few freshly minted methods on the Range types:

• Range::contains
• RangeFrom::contains
• RangeTo::contains
• RangeInclusive::contains
• RangeToInclusive::contains

With these, you can easily check whether a given value exists in a range. For example, you may write:
fn main() {
if (0..=10).contains(&5) {
println!(“Five is included in zero to ten.”);
}
}

Map and split a borrowed RefCell value in two
With Rust 1.35.0, you can now map and split the borrowed value of a RefCell into multiple borrows for different components of the borrowed data:

• Ref::map_split
• RefMut::map_split

Replace the value of a RefCell through a closure
This release introduces a convenience method replace_with on RefCell:

• RefCell::replace_with

With it, you can more ergonomically map and replace the current value of the cell and get back the old value as a result.

Hash a pointer or reference by address, not value
In this release, we have introduced:

• ptr::hash

This function takes a raw pointer and hashes it. Using ptr::hash, you can avoid hashing the pointed-to value of a reference and instead hash the address.

Copy the contents of an Option
From the very beginning with Rust 1.0.0, the methods Option::cloned for Option and Option have allowed you to clone the contents in case of Some(_). However, cloning can sometimes be an expensive operation and the methods opt.cloned() provided no hints to that effect.

With this release of Rust, we introduced:

• Option::copied for both Option and Option

The functionality of opt.copied() is the same as for opt.cloned(). However, calling the method requires that T: Copy. Using this method, you can make sure that code stops compiling should T no longer implements Copy.

Changes in Clippy
In this release of Rust, Clippy (a collection of lints to catch common mistakes and improve your Rust code) added a new lint drop_bounds. This ribbon triggers when you add a bound T: Drop to a generic function. For example:
fn foo

In addition to drop_bounds, this release of Clippy split the lintredundant_closure into redundant_closure and redundant_closure_for_method_calls. See the detailed release notes for Clippy for more details.

Changes in Cargo
See the detailed release notes for Cargo for more details.

Contributors to 1.35.0
Many people came together to create Rust 1.35.0. We couldn’t have done it without all of you. Thanks!