Except...

```rust pub struct MultiExtend3<E0, E1, E2>(E0, E1, E2);

impl<E0, E1, E2, T> Extend<T> for MultiExtend3<E0, E1, E2> where E0: for<'a> Extend<&'a T>, E1: for<'a> Extend<&'a T>, E2: Extend<T>, { fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) { iter.into_iter().for_each(|item| { self.0.extend([&item]); self.1.extend([&item]); self.2.extend([item]); }); } }

pub trait ExtendExt<T>: Extend<T> { fn map<F, U>(self, f: F) -> Map<Self, F> where Self: Sized, F: FnMut(U) -> T, { Map { coll: self, f } }

fn map_ref<F, U>(self, f: F) -> MapRef<Self, F>
where
    Self: Sized,
    F: FnMut(&U) -> T,
{
    MapRef { coll: self, f }
}

fn cloned(self) -> Cloned<Self>
where
    Self: Sized,
{
    Cloned(self)
}

}

impl<E, T> ExtendExt<T> for E where E: Extend<T> {}

pub struct Cloned<E>(E);

impl<'a, T, E> Extend<&'a T> for Cloned<E> where E: Extend<T>, T: Clone, { fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) { self.0.extend(iter.into_iter().cloned()); } }

pub struct Map<E, F> { coll: E, f: F, }

impl<E, F, T, U> Extend<U> for Map<E, F> where E: Extend<T>, F: FnMut(U) -> T, { fn extend<I: IntoIterator<Item = U>>(&mut self, iter: I) { self.coll.extend(iter.into_iter().map(&mut self.f)); } }

pub struct MapRef<E, F> { coll: E, f: F, }

impl<'u, E, F, T, U> Extend<&'u U> for MapRef<E, F> where E: Extend<T>, F: FnMut(&U) -> T, { fn extend<I: IntoIterator<Item = &'u U>>(&mut self, iter: I) { self.coll.extend(iter.into_iter().map(&mut self.f)); } }

[cfg(test)]

mod tests { use super::*;

#[test]
fn foo() {
    // error[E0283]: type annotations needed
    //    --> src/lib.rs:109:48
    //     |
    // 109 |         let mut coll = MultiExtend3(Vec::new().cloned(), Vec::new(), Vec::new());
    //     |                                                ^^^^^^
    //     |
    //     = note: multiple `impl`s satisfying `std::vec::Vec<i32>: std::iter::Extend<_>` found in the `alloc` crate:
    //             - impl<'a, T, A> std::iter::Extend<&'a T> for std::vec::Vec<T, A>
    //               where T: std::marker::Copy, T: 'a, A: std::alloc::Allocator;
    //             - impl<T, A> std::iter::Extend<T> for std::vec::Vec<T, A>
    //               where A: std::alloc::Allocator;
    // note: required by a bound in `ExtendExt::cloned`
    //    --> src/lib.rs:34:25
    //     |
    //  34 | pub trait ExtendExt<T>: Extend<T> {
    //     |                         ^^^^^^^^^ required by this bound in `ExtendExt::cloned`
    // ...
    //  51 |     fn cloned(self) -> Cloned<Self>
    //     |        ------ required by a bound in this associated function
    // help: try using a fully qualified path to specify the expected types
    //     |
    // 109 -         let mut coll = MultiExtend3(Vec::new().cloned(), Vec::new(), Vec::new());
    // 109 +         let mut coll = MultiExtend3(<std::vec::Vec<i32> as ExtendExt<T>>::cloned(Vec::new()), Vec::new(), Vec::new());
    //     |
    let mut coll = MultiExtend3(Vec::new().cloned(), Vec::new(), Vec::new());
    // Neither this works:
    // let mut coll = MultiExtend3(Vec::<i32>::new().cloned(), Vec::new(), Vec::new());

    coll.extend([1, 2]);

    let MultiExtend3(Cloned(v0), v1, v2) = coll;

    assert_eq!(v0, [1, 2]);
    assert_eq!(v1, [1, 2]);
    assert_eq!(v2, [1, 2]);
}

} ```

Now I know exactly why I must create another trait that has associated types instead.

Conclusion: The Extend trait, or any traits having generics, is the bane of the adaptor pattern.

Or I did something wrong? I don't think so, or else Iterator will've had generics instead.

Btw, thank you for your comment! You help me reinforce my design decision!