Rust 1.87, and the standard library grows an anonymous pipe

Rust 1.87 shipped today, ten years and one day after Rust 1.0. The release is a good one and the anniversary is worth a paragraph at the end.

anonymous pipes#

std::io::pipe() gives you a cross-platform anonymous pipe in the standard library:

use std::io::pipe;
use std::process::Command;

let (mut reader, writer) = pipe()?;
let mut child = Command::new("ls")
    .stdout(writer.try_clone()?)
    .stderr(writer)
    .spawn()?;

let mut merged = String::new();
reader.read_to_string(&mut merged)?;
child.wait()?;

Interleaving stdout and stderr into one stream, in order, has been a recurring annoyance requiring either a platform-specific unsafe block or a dependency. Now it is three lines of std.

asm! can jump to Rust#

Inline assembly can now use labels that jump back into Rust code. This is deeply niche and matters enormously to the handful of people writing kernels, bootloaders, and hypervisors in Rust — which, at this point, is a real number of people.

the smaller items#

• Vec::extract_if and LinkedList::extract_if — remove and yield elements matching a predicate, in place, without collecting into a temporary.
• <[T]>::as_chunks — split a slice into fixed-size arrays, safely, with the remainder returned separately. Useful for everything from SIMD prep to parsing.
• i686-pc-windows-gnu demoted to tier 2 without host tools.
• Numerous const fn stabilizations, which continue at a steady drip.

ten years#

Rust 1.0 shipped on 15 May 2015. The stability promise made then has held: code written against 1.0 still compiles, editions handled the syntax evolution without splitting the ecosystem, and there has been no Python 3 moment.

That is the achievement. Not the borrow checker, which is what everybody talks about. The borrow checker is a good idea that several research languages had first. What Rust did that no research language did was ship it with a package manager people liked, a stability guarantee people trusted, and an upgrade path that did not require rewriting anything.

Where it landed in a decade: Linux kernel drivers, Windows kernel components, Android's Bluetooth and media stacks, the core of several CDNs, most new CLI tooling in the JavaScript ecosystem, and a substantial share of new infrastructure software generally.

Where it did not land: application development, mostly. The GUI story is still unsettled after ten years of effort. Async Rust is still the sharpest edge in the language, and the "async traits and lifetime puzzles" complaint from 2020 is only partially resolved.

The honest summary: Rust won the systems niche decisively and did not win general-purpose programming, which is fine, because it was never going to and the systems niche is where the memory-safety bugs were.

Ten more years of the same trajectory and half the internet's infrastructure will be written in it.