How to make Rust function `zip_map` take a binary function instead of a unary function with a 2-tuple as argument?

Question

I have the following code:

pub trait Iterx: Iterator {
    fn zip_map<U, T, F>(self, other: U, f: F) -> Map<Zip<Self, U::IntoIter>, F>
    where
        Self: Sized,
        U: IntoIterator,
        F: Fn((<Self as Iterator>::Item, <U as IntoIterator>::Item)) -> T,
    {
        self.zip(other.into_iter()).map(f) // |(x, y)| f(x, y))
    }
}

It can be used as follows:

    #[test]
    fn test_zip_map() {
        assert_equal((1..5).zip_map(1..5, |(a, b)| a + b), vec![2, 4, 6, 8]);
        assert_equal((1..5).zip_map(1..5, |(a, b)| a * b), vec![1, 4, 9, 16]);
    }

However, I would like it to be able to be used like this:

    #[test]
    fn test_zip_map() {
        assert_equal((1..5).zip_map(1..5, |a, b| a + b), vec![2, 4, 6, 8]);
        assert_equal((1..5).zip_map(1..5, |a, b| a * b), vec![1, 4, 9, 16]);
                                          ^^^^^^
                                      no parentheses
    }

Does anyone know how to modify zip_map to achieve this?

Thank you!

Answer 1

Unfortunately since we can't name the name of a closure and neither can use impl Fn… as the maps second generic we have to use a Boxed trait object.

use std::iter::Map;
use std::iter::Zip;

pub trait Iterx: Iterator {
    fn zip_map<U, T, F>(
        self,
        other: U,
        f: F,
    ) -> Map<
        Zip<Self, U::IntoIter>,
        Box<dyn Fn((<Self as Iterator>::Item, <U as IntoIterator>::Item)) -> T>,
    >
    where
        Self: Sized,
        U: IntoIterator,
        F: Fn(<Self as Iterator>::Item, <U as IntoIterator>::Item) -> T + 'static,
    {
        self.zip(other.into_iter()).map(Box::new(move |(x, y)| f(x, y)))
    }
}
impl<I> Iterx for I where I: Iterator {}

#[test]
fn test_zip_map() {
    assert_eq!(
        (1..5)
            .into_iter()
            .zip_map(1..5, |a, b| a + b)
            .collect::<Vec<_>>(),
        vec![2, 4, 6, 8]
    );
}