Generic error, don't understand error message

I do not understand what it is compiler is saying.
ResponseFuture does not have any type parameter bound, so why impl Trait generated by async is no good?
I tried to look up and_then implementation, which does compile, but could not find any clue.

use std::future::Future;

struct ResponseFuture<F> {
    fut: F,
}

fn request<F: Future>() -> ResponseFuture<F> {
    let req = async {
        Ok(())
    };
    ResponseFuture {fut: req}
}

fn main() {}
error[E0308]: mismatched types
  --> src/main.rs:12:26
   |
12 |     ResponseFuture {fut: req}
   |                          ^^^ expected type parameter, found opaque type
   |
   = note: expected type `F`
              found type `impl std::future::Future`

F is a generic parameter chosen by the calller

You want,

fn request() -> ResponseFuture<impl Future<Output = Result<(), your_error_type_here >> {
    let req = async {
        Ok(())
    };
    ResponseFuture {fut: req}
}

Hmm, that works. What confused me is that I tried to apply constraints like the follow and it did produce the same error as the above. What's the difference?

use std::future::Future;

struct ResponseFuture<F> {
    fut: F,
}

fn request<F: Future<Output=Result<(), String>>>() -> ResponseFuture<F> {
    let req = async {
        Ok(())
    };
    ResponseFuture {fut: req}
}

fn main() {}

Ah, I think I understood.
Compiler is free to call request with any implementation of Future, whereas function in fact produce some very concrete (anonymous) implementation. So, there is a possibility to call request with type param which is incompatible with factually produced by function body.

Yes, this exactly, but more like anyone who calls request can pass in any implementation of Future that they want, not necessarily the same as the one you chose.
Because you are using async, you are guaranteed to get a different implementation.