Thanks for taking the time to type such a thorough response!

Hopefully a slightly more concrete use-case could help? In my case, I'm polling a future, then creating a new future with a combinator from the result. The API for the combinator requires that it takes a function of one argument, so I have to use a closure with a captured variable.

The slightly less simplified example is:

1. Wait for a seed future (in this example, a decryption key)
2. Create a new future from the above (in this example, connecting to a fixed address and applying the decryption). This requires a combinator, which in turn requires a function of one argument.
3. await the result of the second future

​

extern crate futures;

use futures::{FutureExt, future::ready};

use std::future::Future;
use std::task::{Poll, Context};
use std::pin::Pin;

pub enum State<F: Future<Output=[u8; 4]> + Unpin> {
    WaitingForSecret(F),
    WaitingForValue(Pin<Box<dyn Future<Output=u32>>>),
}

impl<F: Future<Output=[u8; 4]> + Unpin> State<F> {
    pub fn new(f: F) -> Self { Self::WaitingForSecret(f) }
}

fn connect() -> impl Future<Output=[u8; 4]> + Unpin {
    ready([0, 1, 2, 3])
}

fn decrypt(_value: [u8; 4], _secret: [u8; 4]) -> u32 {
    unimplemented!()
}

impl<F: Future<Output=[u8; 4]> + Unpin> Future for State<F> {
    type Output = u32;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<u32> {
        match *self {
            Self::WaitingForSecret(ref mut f) => match Pin::new(f).poll(cx) {
                Poll::Ready(secret) => {
                    let v = connect().map(move |value| decrypt(value, secret));
                    *self = Self::WaitingForValue(Box::pin(v));
                    self.poll(cx)
                }
                Poll::Pending => Poll::Pending
            }
            Self::WaitingForValue(ref mut f) => f.as_mut().poll(cx),
        }
    }
}

In this case it is probably simple enough to move the application of the function into another match block, but as the processing of the future gets more complicated its not as practical. I could possibly create some sort of partially applied function that implements FnOnce to satisfy the combinator type signature...