error[E0698]: type inside async object must be known in this context

[kpp]

This code works:

impl<T: ?Sized> FutureExt for T where T: Future {}

#[async_trait]
pub trait FutureExt: Future {
    async fn flatten(self) -> <<Self as Future>::Output as Future>::Output
        where <Self as Future>::Output: Future + Send,
              Self: Sized,
    {
        let nested_future = self.await;
        nested_future.await
    }
}

However if I want to reduce the number of angle brackets, this won't work:

    async fn flatten(self) -> <<Self as Future>::Output as Future>::Output
        where Self::Output: Future + Send,
              Self: Sized,
    {...}


error:
   |
34 |         let nested_future = self.await;
   |             ^^^^^^^^^^^^^ cannot infer type
   |

But this will work:

    async fn flatten(self) -> <<Self as Future>::Output as Future>::Output
        where Self: Future, // hence self is Future whereas we already have FutureExt: Future
              Self::Output: Future + Send,
              Self: Sized,
    {...}

Why? Is it a desired behavior? Also I'd like to reduce angle brackets in the result type, but I failed...

[dtolnay]

Thanks for reporting this! This was hitting a surprising (to me) restriction in rustc's parser. The following code is accepted by rustc:

fn f<T>()
where
    T: std::str::FromStr,
    <T>::Err: Send,
{}

but swapping the where-predicates is not:

fn f<T>()
where
    <T>::Err: Send,
    T: std::str::FromStr,
{}

error: generic parameters on `where` clauses are reserved for future use
  --> src/main.rs:45:5
   |
45 |     <T>::Err: Send,
   |     ^^^ currently unsupported

error[E0412]: cannot find type `Err` in the crate root
  --> src/main.rs:45:10
   |
45 |     <T>::Err: Send,
   |          ^^^ not found in the crate root

I released 0.1.1 with a workaround, so your original code should now work.

#![feature(async_await)]

use async_trait::async_trait;
use std::future::Future;

impl<T: ?Sized> FutureExt for T where T: Future {}

#[async_trait]
pub trait FutureExt: Future {
    async fn flatten(self) -> <<Self as Future>::Output as Future>::Output
    where
        Self::Output: Future + Send,
        Self: Sized,
    {
        let nested_future = self.await;
        nested_future.await
    }
}

[dtolnay]

You should also be able to remove a set of angle brackets from the return type.

-     async fn flatten(self) -> <<Self as Future>::Output as Future>::Output
+     async fn flatten(self) -> <Self::Output as Future>::Output

[kpp]

Nice!

async fn flatten(self) -> <Self::Output as Future>::Output

Very nice!