trait PipeTrait: Iterator {
    fn pipe<T>(self, transform: T) -> Pipe<Self, T>
    where
        Self: Sized,
        T: Transform<In = Self::Item>,
    {
        Pipe::new(self, transform)
    }
}

impl<I: Iterator> PipeTrait for I {}

// Pipe Struct/Impl
struct Pipe<I, T> {
    iter: I,
    transform: T,
}

impl<T: Transform<In = I::Item>, I: Iterator> Pipe<I, T> {
    fn new(iter: I, transform: T) -> Pipe<I, T> {
        Pipe { iter, transform }
    }
}

impl<T: Transform<In = I::Item>, I: Iterator> Iterator for Pipe<I, T> {
    type Item = T::Out;
    fn next(&mut self) -> Option<T::Out> {
        self.transform.transform(&mut self.iter)
    }
}

trait Transform {
    type In;
    type Out;
    fn transform<I: Iterator<Item = Self::In>>(&mut self, iter: &mut I) -> Option<Self::Out>;
}

// Sample Transform implementation
struct SumTransform {
    step: usize,
}
impl Transform for SumTransform {
    type In = i32;
    type Out = i32;
    fn transform<I: Iterator<Item = Self::In>>(&mut self, iter: &mut I) -> Option<Self::Out> {
        if let None = iter.peekable().peek() {
            return None
        }
        Some(iter.take(self.step).sum::<i32>())
    }
}

fn main() {
    for v in (1..1000)
        .pipe(SumTransform { step: 3 })
        .pipe(SumTransform { step: 2 })
        .pipe(SumTransform { step: 5 })
    {
        println!("v {}", v);
    }
}