This error occurs when the compiler is unable to unambiguously infer the return type of a function or method which is generic on return type, such as the collect method for Iterators.

For example:

fn foo() -> Result<bool, ()> {
    let results = [Ok(true), Ok(false), Err(())].iter().cloned();
    let v: Vec<bool> = results.collect()?;
    // Do things with v...
    Ok(true)
}

Here we have an iterator results over Result<bool, ()>. Hence, results.collect() can return any type implementing FromIterator<Result<bool, ()>>. On the other hand, the ? operator can accept any type implementing Try.

The author of this code probably wants collect() to return a Result<Vec<bool>, ()>, but the compiler can‘t be sure that there isn’t another type T implementing both Try and FromIterator<Result<bool, ()>> in scope such that T::Ok == Vec<bool>. Hence, this code is ambiguous and an error is returned.

To resolve this error, use a concrete type for the intermediate expression:

fn foo() -> Result<bool, ()> {
    let results = [Ok(true), Ok(false), Err(())].iter().cloned();
    let v = {
        let temp: Result<Vec<bool>, ()> = results.collect();
        temp?
    };
    // Do things with v...
    Ok(true)
}

Note that the type of v can now be inferred from the type of temp.