The async_auto_traits from jplatte

async_auto_traits's Introduction

☀️ Solarpunk
🌐 Open Source advocate
🦀 Rust developer
🐧 Linux poweruser

Things I created

caniuse.rs – Check which version of Rust stabilized a certain feature
turbo.fish – A little joke website
cargo depgraph - Creates graphviz dependency graphs for Rust projects that use Cargo
serde_html_form – Rust crate for (de-)serialization of application/x-www-form-urlencoded data
eyeball – Add observability to your Rust types!
hinoki (WIP) – A simple, yet very flexible static site generator

Things I contributed a lot to

Ruma (@ruma) – Matrix libraries for Rust
axum ⭐️ – Rust web application framework
tower-http – Rust HTTP server utilities

async_auto_traits's People

Contributors

Watchers

async_auto_traits's Issues

Enforce no (stable) auto traits are implemented for the returned Future

Currently #[clear] (and maybe also #[set]) do not enforce that as this compiles:

#[async_auto_traits::clear]
async fn foo() {}

fn assert_send(_: impl Send) {}

fn main() {
    assert_send(foo());
}

Because impl Future does not hide auto traits.

The enforcement could be done through something like this (play):

use pin_project_lite::pin_project;
use std::{
    future::Future,
    marker::PhantomData,
    pin::Pin,
    task::{Context, Poll},
};

pin_project! {
    pub struct NotSendButSyncFuture<F: Future> {
        #[pin]
        future: F,
        ghost: PhantomData<*const ()>,
    }
}

unsafe impl<F: Future + Sync> Sync for NotSendButSyncFuture<F> {}

impl<F: Future> NotSendButSyncFuture<F> {
    pub fn new(future: F) -> Self {
        Self {
            future,
            ghost: PhantomData,
        }
    }
}

impl<F: Future> Future for NotSendButSyncFuture<F> {
    type Output = F::Output;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        self.project().future.poll(cx)
    }
}

fn foo() -> impl Future {
    NotSendButSyncFuture::new(async move { todo!() })
}

fn assert_send(_: impl Send) {}

fn main() {
    assert_send(foo());
}

Or something like this (but may not work properly for async fns that have no .await, play):

use std::{future, marker::PhantomData};

async fn foo() {
    let _phantom = PhantomData::<*mut ()>;
    future::ready(()).await;
}

fn assert_send_sync(_: impl Send + Sync) {}

fn main() {
    assert_send_sync(foo());
}