Download 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, Box, and Box respectively. Additionally, closures may now be coerced to unsafe function pointers. The dbg! macro introduced in Rust 1.32.0 can now also be called without arguments. Moreover, there were a number of standard library stabilizations. Read on for a few highlights, or see the detailed release notes for additional information.

Fn* closure traits implemented for Box
In Rust 1.35.0, the FnOnce, FnMut, and the Fn traits are now implemented for Box, Box, and Box respectively. Previously, if you wanted to call the function stored in a boxed closure, you had to use FnBox. This was because instances of Box and friends did not implement the respective Fn* traits. This also meant that it was not possible to pass boxed functions to code expecting an implementor of a Fn trait, and you had to create temporary closures to pass them down. This was ultimately due to a limitation in the compiler’s ability to reason about such implementations, which has since been fixed with the introduction of unsized locals. With this release, you can now use boxed functions in places that expect items implementing a function trait.

The following code now works:
fn foo(x: Box u8>) -> Vec {
vec![1, 2, 3, 4].into_iter().map(x).collect()
}

Furthermore, you can now directly call Box objects:
fn foo(x: Box) {
X()
}

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<&T>
From the very beginning with Rust 1.0.0, the methods Option::cloned for Option<&T> and Option<&mut T> 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<&T> and Option<&mut T>

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(x: T) {}
Having a bound T: Drop is almost always a mistake as it excludes types, such as u8, which have trivial drop-glues. Moreover, T: Drop does not account for types like String not having interesting destructor behavior directly but rather as a result of embedding types, such as Vec, that do.

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!