fn map<U, F>(self, f: F) -> Map<Self, F>
    where
        F: FnOnce(Self::Output) -> U,
        Self: Sized,
    {
        assert_future::<U, _>(Map::new(self, f))
    }
Map this future's output to a different type, returning a new future of
the resulting type.

This function is similar to the `Option::map` or `Iterator::map` where
it will change the type of the underlying future. This is useful to
chain along a computation once a future has been resolved.

Note that this function consumes the receiving future and returns a
wrapped version of it, similar to the existing `map` methods in the
standard library.

# Examples

```
# futures::executor::block_on(async {
use futures::future::FutureExt;

let future = async { 1 };
let new_future = future.map(|x| x + 3);
assert_eq!(new_future.await, 4);
# });
```
futures-util/src/future/future/mod.rs