both.rs

// This is a rather inefficient version of a function that executes a closure on two arguments, concurrently.
// We need an iterator that yields two owned elements, and we'd like to avoid heap allocation.
mod both {
    struct TwoElements<T> {
        el1: Option<T>,
        el2: Option<T>,
    }
    impl<T> TwoElements<T> {
        fn new(x: T, y: T) -> Self {
            TwoElements { el1: Some(x), el2: Some(y) }
        }

        fn iter(&mut self) -> Iter<T> {
            Iter { elems: self }
        }
    }
    struct Iter<'a, T> where T: 'a {
        elems: &'a mut TwoElements<T>,
    }
    impl<'a, T> Iterator for Iter<'a, T> {
        type Item = T;
        fn next(&mut self) -> Option<Self::Item> {
            let el = self.elems.el1.take();
            if let Some(x) = el {
                Some(x)
            }
            else {
                self.elems.el2.take()
            }
        }
    }

    pub fn both<T, F>(x: T, y: T, f: F)
        where T: Send,
            F: Sync + Fn(T)
    {
        use simple_parallel::Pool;
        let mut pool = Pool::new(2);
        pool.for_(TwoElements::new(x, y).iter(), f);
    }
}