Propane: an experimental generator syntax for Rust


I’ve just released a new crate called propane, which is a library for writing generator functions. It can only run on nightly: #![feature(generators, generator_trait, try_trait)]#[propane::generator]fn fizz_buzz()-> String {forxin1..101{match(x%3==0,x%5==0){(true,true)=>yieldString::from("FizzBuzz"),(true,false)=>yieldString::from("Fizz"),(false,true)=>yieldString::from("Buzz"),(..)=>yieldx.to_string(),}}}Note that I wrote this library in an afternoon (cribbing from work I’d previously done in fehler and futures-await). It’s very likely that the macro barfs on a lot of input, some exotic and some not. It currently only works at all on free functions.…

Read more ⟶

Shipping Const Generics in 2020


It’s hard to believe that its been more than 3 years since I opened RFC 2000, which defined the const generics for Rust. At the same time, reading the RFC thread, there’s also been a huge amount of change in this area: for one thing, at the time the RFC was written, const fns weren’t stable, and consts weren’t even being evaluated using miri yet. There’s been a lot of work over the years on the const generics feature, but still nothing has shipped.…

Read more ⟶

Ringbahn II: the central state machine


Last time I wrote about ringbahn, a safe API for using io-uring from Rust. I wrote that I would soon write a series of posts about the mechanism that makes ringbahn work. In the first post in that series, I want to look at the core state machine of ringbahn which makes it memory safe. The key types involved are the Ring and Completion types. Note: the API has evolved since my previous post.…

Read more ⟶

Two Memory Bugs From Ringbahn


While implementing ringbahn, I introduced at least two bugs that caused memory safety errors, resulting in segfaults, allocator aborts, and bizarre undefined behavior. I’ve fixed both bugs that I could find, and now I have no evidence that there are more memory safety issues in the current codebase (though that doesn’t mean there aren’t, of course). I wanted to write about both of these bugs, because they had an interesting thing in common: they were both caused by destructors.…

Read more ⟶

Futures and Segmented Stacks


This is just a note on getting the best performance out of an async program. The point of using async IO over blocking IO is that it gives the user program more control over handling IO, on the premise that the user program can use resources more effectively than the kernel can. In part, this is because of the inherent cost of context switching between the userspace and the kernel, but in part it is also because the user program can be written with more specific understanding of its exact requirements.…

Read more ⟶

Ringbahn: a safe, ergonomic API for io-uring in Rust


In my previous post, I discussed the new io-uring interface for Linux, and how to create a safe API for using io-uring from Rust. In the time since that post, I have implemented a prototype of such an API. The crate is called ringbahn, and it is intended to enable users to perform IO on io-uring without any risk of memory unsafety. io-uring is going to be majorly important to the development of async IO on Linux in the future, and Linux is the most used platform for the kinds of high performance network services that are a major user of Rust.…

Read more ⟶

Notes on io-uring


Last fall I was working on a library to make a safe API for driving futures on top of an an io-uring instance. Though I released bindings to liburing called iou, the futures integration, called ostkreuz, was never released. I don’t know if I will pick this work up again in the future but several different people have started writing other libraries with similar goals, so I wanted to write up some notes on what I learned working with io-uring and Rust’s futures model.…

Read more ⟶

The problem of effects in Rust


In a previous post, I shortly discussed the concept of “effects” and the parallels between them. In an unrelated post since then, Yosh Wuyts writes about the problem of trying to write fallible code inside of an iterator adapter that doesn’t support it. In a previous discussion, the users of the Rust Internals forum hotly discuss the notion of closures which would maintain the so-called “Tennant’s Correspondence Principle” - that is, closures which support breaking to scopes outside of the closure, inside of the function they are in (you can think of this is closures capturing their control flow environment in addition to capturing variables).…

Read more ⟶

A brief apology of Ok-Wrapping


I’ve long been a proponent of having some sort of syntax in Rust for writing functions which return results which “ok-wrap” the happy path. This is has also always been a feature with very vocal, immediate, and even emotional opposition from many of our most enthusiastic users. I want to write, in one place, why I think this feature would be awesome and make Rust much better. I don’t want to get into the details too much of the specific proposal, but here’s a sketch of one way this could work (there are a number of variables).…

Read more ⟶

From failure to Fehler


About two and a half years ago I wrote a Rust library called failure, which quickly became one of the most popular error handling libraries in Rust. This week, its current maintainer decided to deprecate it, a decision I strongly support. This week, I also released a new and very different error-handling library, called fehler. I wanted to discuss these two libraries briefly. A brief history of failure When I released failure, the most popular error handling library by far was error-chain.…

Read more ⟶