Refactoring use common code between option, result and accum

[Stargateur]

Option and Result have almost exactly the same code that in accum.rs that implement Sum and Product. This PR just move some code to use the same code for all of them. I believe is better to not implement this Iterator feature twice.

I'm not very familiar with pub visibility hope I didn't make then public. However, maybe these adapters could be useful and we could think to make then pub.

#59605
#11084

r? @pnkfelix

[Stargateur]

I get an idea from #58975 (comment)

/// An iterator adapter that produces output as long as the underlying
/// iterator produces `Option::Some` values.
pub(crate) struct OptionShunt;

impl OptionShunt
{
    /// Process the given iterator as if it yielded a `T` instead of a
    /// `Option<T>`. Any `None` value will stop the inner iterator and
    /// the overall result will be a `None`.
    pub fn process<I, T, F, U, O>(iter: I, f: F) -> Option<U>
    where
        I: Iterator<Item = Option<T>>,
        O: Iterator<Item = Result<T, ()>>,
        F: FnMut(&mut ResultShunt<O, ()>) -> U,
    {
        ResultShunt::process(iter.map(|x| x.ok_or(())), f).ok()
    }
}

but I don't make it to compile, I don't think it's possible:

error[E0282]: type annotations needed for `&mut iter::adapters::ResultShunt<O, ()>`
   --> src/libcore/iter/traits/accum.rs:183:37
    |
183 |         OptionShunt::process(iter, |i| i.sum())
    |                                     ^ consider giving this closure parameter the explicit type `&mut iter::adapters::ResultShunt<O, ()>`, where the type parameter `O` is specified

error[E0277]: expected a `ops::function::FnMut<(&mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` closure, found `F`
    --> src/libcore/iter/adapters/mod.rs:2081:9
     |
2081 |         ResultShunt::process(iter.map(|x| x.ok_or(())), f).ok()
     |         ^^^^^^^^^^^^^^^^^^^^ expected an `FnMut<(&mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` closure, found `F`
     |
     = help: the trait `for<'r> ops::function::FnMut<(&'r mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` is not implemented for `F`
     = help: consider adding a `where for<'r> F: ops::function::FnMut<(&'r mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` bound
note: required by `iter::adapters::ResultShunt::<I, E>::process`
    --> src/libcore/iter/adapters/mod.rs:2102:5
     |
2102 | /     pub fn process<F, U>(iter: I, mut f: F) -> Result<U, E>
2103 | |         where F: FnMut(&mut Self) -> U
2104 | |     {
2105 | |         let mut shunt = ResultShunt::new(iter);
2106 | |         let value = f(shunt.by_ref());
2107 | |         shunt.reconstruct(value)
2108 | |     }
     | |_____^

error[E0277]: expected a `ops::function::FnOnce<(&mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` closure, found `F`
    --> src/libcore/iter/adapters/mod.rs:2081:9
     |
2081 |         ResultShunt::process(iter.map(|x| x.ok_or(())), f).ok()
     |         ^^^^^^^^^^^^^^^^^^^^ expected an `FnOnce<(&mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` closure, found `F`
     |
     = help: the trait `ops::function::FnOnce<(&mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` is not implemented for `F`
     = help: consider adding a `where F: ops::function::FnOnce<(&mut iter::adapters::ResultShunt<iter::adapters::Map<I, [closure@src/libcore/iter/adapters/mod.rs:2081:39: 2081:54]>, ()>,)>` bound
note: required by `iter::adapters::ResultShunt::<I, E>::process`
    --> src/libcore/iter/adapters/mod.rs:2102:5
     |
2102 | /     pub fn process<F, U>(iter: I, mut f: F) -> Result<U, E>
2103 | |         where F: FnMut(&mut Self) -> U
2104 | |     {
2105 | |         let mut shunt = ResultShunt::new(iter);
2106 | |         let value = f(shunt.by_ref());
2107 | |         shunt.reconstruct(value)
2108 | |     }
     | |_____^

Also, I'm not sure it better to do this.

[scottmcm]

r? @scottmcm

(Per #62459 (comment))

[scottmcm]

This seems like a good simplification to me. And pub(crate) is fine -- tidy would have yelled at you if you'd accidentally exposed something without a stability marker.

@bors r+ rollup

[bors]

📌 Commit 3334802 has been approved by scottmcm