Polls multiple futures and streams simultaneously, executing the branch for the future that finishes first. If multiple futures are ready, one will be pseudo-randomly selected at runtime. Futures directly passed to `select!` must be `Unpin` and implement `FusedFuture`.| docs.rs
In 2013, I discovered the Rust programming language and quickly decided to learn it and make it my main programming language.| Medium
I want to address a controversy that has gripped the Rust community for the past year or so: the| without.boats
Empowering everyone to build reliable and efficient software.| blog.rust-lang.org
Tree-Structured Concurrency| blog.yoshuawuyts.com
Tasks are the wrong abstraction| blog.yoshuawuyts.com
Tokio is a runtime for writing reliable asynchronous applications with Rust. It provides async I/O, networking, scheduling, timers, and more.| tokio.rs
In the previous post, I introduced the “send bound” problem, which refers to the need to add a Send bound to the future returned by an async function. I want to start talking about some of the ideas that have been floating around for how to solve this problem. I consider this a bit of an open problem, in that I think we know a lot of the ingredients, but there is a bit of a “delicate balance” to finding the right syntax and so forth. To start with, though, I want to introduce Return T...| smallcultfollowing.com
Builds Tokio Runtime with custom configuration values.| docs.rs
In the early-to-mid 2010s, there was a renaissance in languages exploring new ways of doing| without.boats
What If We Pretended That a Task = Thread?| blaz.is
A set of futures which may complete in any order.| docs.rs
Spawns a new asynchronous task, returning a `JoinHandle` for it.| docs.rs
For just about as long as I’ve been working on async Rust, the topic of scoped tasks has come up. These are async tasks that borrow from their environment, and they would come in handy in a lot of situations. Last year the standard library stabilized thread::scope which allows synchronous threads to do this. You could imagine a similar API, but with async: asyncfn fanout(data: &Vec){task::scope(|s|{// Spawn subtasks to run in parallel.| Tyler Mandry
goto: the destroyer of abstraction| vorpus.org
Nightly Rust now has support for async functions in traits, so long as you limit yourself to static dispatch. That’s super exciting! And yet, for many users, this support won’t yet meet their needs. One of the problems we need to resolve is how users can conveniently specify when they need an async function to return a Send future. This post covers some of the background on send futures, why we don’t want to adopt the solution from the async_trait crate for the language, and the general...| smallcultfollowing.com
The Tokio runtime.| docs.rs
Local Async Executors and Why They Should be the Default| maciej.codes
This is the first post in a series of posts about concurrency in Rust, and the different APIs that| without.boats
I previously introduced the “send bound” problem, which refers to the need to add a Send bound to the future returned by an async function. This post continues my tour over the various solutions that are available. This post covers “Trait Transformers”. This proposal arose from a joint conversation with myself, Eric Holk, Yoshua Wuyts, Oli Scherer, and Tyler Mandry. It’s a variant of Eric Holk’s inferred async send bounds proposal as well as the work that Yosh/Oli have been doing ...| smallcultfollowing.com