Combining a Future with and_then throws compilation error in Rust - rust

Question

I am trying to be comfortable with the idioms of handing Future in Rust.
The idea is that there are two async functions: one's output is another's input.
The first function pairs a bunch of integers along with a bunch of characters.
async fn squeeze_in(elems: [i32;5]) -> Data1 {
let allowed_chars = ['a','b','c','d','e'];
let together = zip(allowed_chars,elems);
let mut data1 = Data1::new();
for _i in together {
data1.append(_i.0,_i.1);
}
data1
}
The other one, takes this list of pairs and gives the the same list but the positions of the elements in a pair, reversed .
async fn blow_out(data1: &Data1) -> Data1Reversed {
let holder: Vec<(i32,char)> = vec![];
let reversed = data1.val1.iter()
.fold(
holder,
| mut accu, next_pair | {
accu.push((next_pair.1,next_pair.0));
accu
}
);
Data1Reversed::new(reversed)
}
The structs Data1 and Data1Reversed are defined, thus:
use std::iter::zip;
use futures::{StreamExt, TryFutureExt};
use futures::FutureExt;
#[derive(Debug)]
struct Data1 {
pub val1: Vec<(char,i32)>
}
impl Data1 {
pub fn new() -> Data1 {
Data1 { val1: vec![] }
}
pub fn append(&mut self, elem_char: char, elem_int: i32) {
self.val1.push((elem_char,elem_int));
}
}
#[derive(Debug)]
struct Data1Reversed {
pub val2: Vec<(i32,char)>
}
impl Data1Reversed {
pub fn new(elems: Vec<(i32,char)>) -> Data1Reversed {
Data1Reversed {
val2: elems
}
}
}
This arrangement, where two functions are called one after the other, after awaiting, works.
However, I want to arrange the flow in a continuation, thus:
let squeezed_and_blown = squeeze_in(some_num).and_then(move |data1| blow_out(&data1)) ;
My understanding is that, each of the functions being async, each produces a future. A flow like a future1.and_then(future2) should be permissible. The compiler doesn't think so, though:
error[E0599]: the method `and_then` exists for opaque type `impl futures::Future<Output = Data1>`, but its trait bounds were not satisfied
--> src/main.rs:38:51
|
38 | let squeezed_and_blown = squeeze_in(some_num).and_then(|data1| blow_out(&data1) ) ;
| ^^^^^^^^ method cannot be called on `impl futures::Future<Output = Data1>` due to unsatisfied trait bounds
|
= note: the following trait bounds were not satisfied:
`impl futures::Future<Output = Data1>: TryFuture`
which is required by `impl futures::Future<Output = Data1>: TryFutureExt`
`&impl futures::Future<Output = Data1>: TryFuture`
which is required by `&impl futures::Future<Output = Data1>: TryFutureExt`
`&mut impl futures::Future<Output = Data1>: TryFuture`
which is required by `&mut impl futures::Future<Output = Data1>: TryFutureExt`
I have visited this conversation, if I get an hint of where I am going wrong, but that is not the case. The problem in my case, is with the first future and not what is provided to and_then.
What is confusing me is this message from the compiler:
error[E0599]: the method `and_then` exists for opaque type `impl futures::Future<Output = Data1>`, but its trait bounds were not satisfied
What is it unhappy about?
In response to #Jmb's comment below, here is how I want to use the functions:
// Here, a single future is used. However, the actual functionality requires a set of
// futures to be launched.
let maybe_reveresed =
tokio::spawn({
squeeze_in(some_num)
.and_then(|data1| { blow_out(&data1) })
// and, I can add many such operations, serially here.
}
);
// Here again, the actual functionality requires us to join a number of futures obtained earlier.
let have_we_got_it_reversed = maybe_reveresed.await;
// .. rest of implementation.