A monad is a type that looks like a collection and has a flat_map function. A Vec<T> is a monad. An Option<T> is a monad (it's a collection with zero or one elements) and its flat_map is called and_then. A Future is a monad (it's a collection with exactly one element), although you have to squint as the element doesn't quite exist yet. It's flat_map is then.
The reason people really like these monad types is what haskell calls do-notation. For the case of Option, do notation is the question mark operator. For the case of Future, do notation is the async/await syntax.
For Vec<T>, do notation is be pretty weird. Consider the following code with made-up syntax:
fn foo(a: Vec<u32>) -> Vec<u32> {
let item: u32 = a?;
println!("{}", item);
let item2: u32 = vec![item, item]?;
return item2;
}
In this case I have borrowed the question mark to refer to vector's flat_map instead of option's and_then. In this context, the question mark would run the remaining code in the function for every item in the vector, so the snippet above would print every item in the vector, and return a vector with each item duplicated, so foo(vec![1, 2, 3]) = vec![1, 1, 2, 2, 3, 3].
If you think about what the question mark does on options, it is actually the same thing. If the option is None the collection has zero elements, and the rest of the code runs zero times. If it is Some, there is one element, and the rest of the code runs once. Similarly, a Future always has exactly one item, so the rest of the code runs once.
Anyway, do notation is a generalization of the question mark and async/await syntax, and using do notation, you could reimplement async/await syntax in haskell as a library, without any special compiler support for Futures whatsoever.
(to be exact, you would need ok-wrapping for the question mark operator to truly be do notation for options)