Real async closures don't work with associated types in traits

[inga-lovinde]

Setup

Versions

• Rust: 1.95.0

Problem Description

This is not a problem in diesel_async, but something that people using diesel_async are likely to encounter, so I want to document this here just in case for the other users, along with the possible workaround. Maybe, if you ever decide to make AsyncFunc public, you'll want to adapt this workaround.

The problem is that building code around diesel_async in codebases with wrappers around connections and transactions still requires one to use scoped futures, or to use a different set of tricks; AsyncFunc doesn't work there.

What are you trying to accomplish?

To use new AsyncFunc (as introduced in #284) in higher-level code consuming diesel_async, in order to have connection wrappers and transaction wrappers performing some additional work, with method similar to .transaction and calling diesel_async's transaction under the hood.

What is the expected output?

Code compiles.

What is the actual output?

Rust produces compile-time errors: even for identical trait and implementation function signatures (including trait bounds), it considers trait bounds on arguments to not be equivalent when these trait bounds (1) use trait associated types and (2) constrain them to traits with explicit associated types on their own.

I cannot describe it in a way that makes sense because I'm not a rust expert, so just see the examples below.

This might be a bug in rustc, but I don't know rustc enough to file a bug there (maybe that's the same bug as reported in rust-lang/rust#137639 ?), and in #284 you seemed to be interested in other people's workarounds for rustc weirdness such as lcnr/random-rust-snippets#26 , so maybe this will help too.

Are you seeing any additional errors?

No

Steps to reproduce

This self-contained (can be just inserted into rust playground) code does not compile:

use std::future::Future;

pub trait AsyncFunc<T, R>:
    AsyncFnOnce(T) -> R + FnOnce(T) -> <Self as AsyncFunc<T, R>>::Fut
{
    type Fut: Future<Output = R>;
}

pub trait Transactionable {
    type Transaction;

    fn transaction<'a, 'conn, R, E, F>(
        &'conn mut self,
        callback: F,
    ) -> impl Future<Output = Result<R, E>> + Send + 'conn
    where
        for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
            + AsyncFunc<&'r mut Self::Transaction, Result<R, E>, Fut: Send>
            + Send
            + 'a,
        E: Send + 'a,
        R: Send + 'a,
        'a: 'conn;
}

pub struct ConnectionWrapper;
pub struct TransactionWrapper;

impl Transactionable for ConnectionWrapper {
    type Transaction = TransactionWrapper;

    fn transaction<'a, 'conn, R, E, F>(
        &'conn mut self,
        callback: F,
    ) -> impl Future<Output = Result<R, E>> + Send + 'conn
    where
        for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
            + AsyncFunc<&'r mut Self::Transaction, Result<R, E>, Fut: Send>
            + Send
            + 'a,
        E: Send + 'a,
        R: Send + 'a,
        'a: 'conn
    {
        async {
            unimplemented!()
        }
    }
}

The errors are:

   Compiling playground v0.0.1 (/playground)
error[E0277]: the trait bound `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not satisfied
  --> src/main.rs:32:5
   |
32 | /     fn transaction<'a, 'conn, R, E, F>(
33 | |         &'conn mut self,
34 | |         callback: F,
35 | |     ) -> impl Future<Output = Result<R, E>> + Send + 'conn
...  |
42 | |         R: Send + 'a,
43 | |         'a: 'conn
   | |_________________^ the trait `for<'r> AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not implemented for `F`

error[E0276]: impl has stricter requirements than trait
  --> src/main.rs:37:20
   |
12 | /     fn transaction<'a, 'conn, R, E, F>(
13 | |         &'conn mut self,
14 | |         callback: F,
15 | |     ) -> impl Future<Output = Result<R, E>> + Send + 'conn
...  |
22 | |         R: Send + 'a,
23 | |         'a: 'conn;
   | |__________________- definition of `transaction` from trait
...
37 |           for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl has extra requirement `for<'r> F: AsyncFnOnce(&'r mut TransactionWrapper)`

error[E0276]: impl has stricter requirements than trait
  --> src/main.rs:38:15
   |
12 | /     fn transaction<'a, 'conn, R, E, F>(
13 | |         &'conn mut self,
14 | |         callback: F,
15 | |     ) -> impl Future<Output = Result<R, E>> + Send + 'conn
...  |
22 | |         R: Send + 'a,
23 | |         'a: 'conn;
   | |__________________- definition of `transaction` from trait
...
38 |               + AsyncFunc<&'r mut Self::Transaction, Result<R, E>, Fut: Send>
   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl has extra requirement `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>`

error[E0277]: the trait bound `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not satisfied
  --> src/main.rs:38:71
   |
38 |             + AsyncFunc<&'r mut Self::Transaction, Result<R, E>, Fut: Send>
   |                                                                       ^^^^ the trait `for<'r> AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not implemented for `F`

error[E0277]: the trait bound `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not satisfied
  --> src/main.rs:35:10
   |
35 |     ) -> impl Future<Output = Result<R, E>> + Send + 'conn
   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'r> AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not implemented for `F`

error[E0276]: impl has stricter requirements than trait
  --> src/main.rs:37:62
   |
12 | /     fn transaction<'a, 'conn, R, E, F>(
13 | |         &'conn mut self,
14 | |         callback: F,
15 | |     ) -> impl Future<Output = Result<R, E>> + Send + 'conn
...  |
22 | |         R: Send + 'a,
23 | |         'a: 'conn;
   | |__________________- definition of `transaction` from trait
...
37 |           for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
   |                                                                ^^^^^^^^^^^^ impl has extra requirement `for<'r> F: AsyncFnOnce(&'r mut TransactionWrapper)`

error[E0276]: impl has stricter requirements than trait
  --> src/main.rs:17:20
   |
17 |         for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl has extra requirement `for<'r> F: AsyncFnOnce(&'r mut TransactionWrapper)`

error[E0276]: impl has stricter requirements than trait
  --> src/main.rs:18:15
   |
18 |             + AsyncFunc<&'r mut Self::Transaction, Result<R, E>, Fut: Send>
   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl has extra requirement `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>`

error[E0277]: the trait bound `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not satisfied
  --> src/main.rs:18:71
   |
18 |             + AsyncFunc<&'r mut Self::Transaction, Result<R, E>, Fut: Send>
   |                                                                       ^^^^ the trait `for<'r> AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not implemented for `F`

error[E0276]: impl has stricter requirements than trait
  --> src/main.rs:17:62
   |
17 |         for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
   |                                                              ^^^^^^^^^^^^ impl has extra requirement `for<'r> F: AsyncFnOnce(&'r mut TransactionWrapper)`

error[E0277]: the trait bound `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not satisfied
  --> src/main.rs:35:10
   |
35 |     ) -> impl Future<Output = Result<R, E>> + Send + 'conn
   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'r> AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not implemented for `F`
   |
note: required by a bound in `<ConnectionWrapper as Transactionable>::transaction`
  --> src/main.rs:38:15
   |
32 |     fn transaction<'a, 'conn, R, E, F>(
   |        ----------- required by a bound in this associated function
...
38 |             + AsyncFunc<&'r mut Self::Transaction, Result<R, E>, Fut: Send>
   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<ConnectionWrapper as Transactionable>::transaction`

error[E0277]: the trait bound `for<'r> F: AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not satisfied
  --> src/main.rs:45:9
   |
45 |         async {
   |         ^^^^^ the trait `for<'r> AsyncFunc<&'r mut TransactionWrapper, Result<R, E>>` is not implemented for `F`

Note that the definition of AsyncFunc in the snippet above is just copied as is from diesel_async without any changes, and that in this snippet we don't even implement AsyncFunc for anything.

Note that the signature of transaction method is copied as is from diesel_async (including the constraints) with one changes: instead of &'r mut Self, F is expected to receive &'r mut Self::Transaction.

---

Replacing Self::Transaction with Self (or with any fixed type such as u8) solves the compile-time errors.

Removing + AsyncFunc<...> constraint on F also solves the compile-time errors.

Updating AsyncFunc definition to say

type Fut: Future<Output = R> + Send;

and removing , Fut: Send trait bound from transaction method signature does not solve the compile-time errors.

---

What does solve the compile-time errors while preserving the benefits AsyncFunc brings us (i.e. constraining future returned by F to be Send) is removing explicit associated type from AsyncFunc and using implicit associated type instead (by having a function that returns impl ...):

use std::future::Future;

pub trait AsyncFunc<T, R>:
    AsyncFnOnce(T) -> R
{
    fn call(self, arg: T) -> impl Future<Output = R> + Send;
}

impl<F, T, Fut, R> AsyncFunc<T, R> for F
where
    F: AsyncFnOnce(T) -> R + FnOnce(T) -> Fut,
    Fut: Future<Output = R> + Send,
{
    #[inline(always)]
    fn call(self, arg: T) -> impl Future<Output = R> + Send {
        self(arg)
    }
}

pub trait Transactionable {
    type Transaction;

    fn transaction<'a, 'conn, R, E, F>(
        &'conn mut self,
        callback: F,
    ) -> impl Future<Output = Result<R, E>> + Send + 'conn
    where
        for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
            + AsyncFunc<&'r mut Self::Transaction, Result<R, E>>
            + Send
            + 'a,
        E: Send + 'a,
        R: Send + 'a,
        'a: 'conn;
}

pub struct ConnectionWrapper;
pub struct TransactionWrapper;

impl Transactionable for ConnectionWrapper {
    type Transaction = TransactionWrapper;

    fn transaction<'a, 'conn, R, E, F>(
        &'conn mut self,
        callback: F,
    ) -> impl Future<Output = Result<R, E>> + Send + 'conn
    where
        for<'r> F: AsyncFnOnce(&'r mut Self::Transaction) -> Result<R, E>
            + AsyncFunc<&'r mut Self::Transaction, Result<R, E>>
            + Send
            + 'a,
        E: Send + 'a,
        R: Send + 'a,
        'a: 'conn
    {
        async {
            unimplemented!()
        }
    }
}

This snippet does compile successfully without errors.

The drawback is that, inside transaction implementation, we'd have to invoke callback with callback.call(transaction) instead of callback(transaction) in order to get a future that is Send.

But I think that's a small price to pay for a working workaround.

Checklist

• I have already looked over the issue tracker for similar possible closed issues.
• This issue can be reproduced on Rust's stable channel. (Your issue will be closed if this is not the case)
• This issue can be reproduced without requiring a third party crate

[weiznich]

Thanks for sharing these information. That's useful and welcome. Although as you wrote that's not an issue with diesel-async, so I converted this to a discussion instead.

Ultimately this is still a workaround for a language limitation (not being able to specify trait bounds for the future returned by an AsyncFnOnce in an obvious way) or at least a compiler limitation (rustc failing to infer the return type of Fn* traits in certain situations). Both issues can and should be fixed upstream, that's also something the relevant people in the types/compiler team agree on. I'm certain that contributions there are welcome.

[Vrajs16]

Thanks @inga-lovinde. I was stuck on this for a few days, but got it working now. Posted a solution on StackOverflow.