Specialize WithPosition::fold

[Philippe-Cholet]

Each call to f is done with a Position variant known at compile time so I think it might be optimized away in some cases?

Without specialization: [5.3231 µs 5.3487 µs 5.3806 µs]
With specialization:    [2.6974 µs 2.7042 µs 2.7132 µs]

We should mention #755 in PRs that specialize fold (such as this one) to help keep track of the advancement of the TODO list I'm gonna make there.

[phimuemue]

Hi @Philippe-Cholet! Nice idea.

[phimuemue]

Do we actually need to set handled_first=true? self is consumed and handled_first seems unused afterwards.

[phimuemue]

I'm somehow bothered because we call peekable.next here, even though we called peekable.peek some lines before. I'm not sure if we can easily avoid this (without convoluting control flow too much)...

Maybe something like this (only a draft - didn't test it):

    if let Some(head) = if !handled_first {
        if let Some(first) = self.peekable.next() {
            match self.peekable.next() {
                Some(head) => {
                    init = {
                        f(init, (Position::First, first));
                        Some(head)
                    }
                }
                None => return f(init, (Position::Only, first)),
            }
        }
    } else {
        self.peekable.next()
    } {
        // Have seen the first item, and there's something left.
        init = self.peekable.fold(init, |acc, mut item| {
            std::mem::swap(&mut head, &mut item);
            f(acc, (Position::Middle, item))
        });
        // The "head" is now the last item.
        init = f(init, (Position::Last, head));
    }

@Philippe-Cholet You can use your judgement here.

[Philippe-Cholet]

@phimuemue
I do not update handled_first field anymore, as it's consumed.
I avoid to peek entirely, the bench become even faster. Control flow is quite updated but remains nice, might be even nicer.
And rebased on master.

[5.4031 µs 5.4195 µs 5.4353 µs] // without specialization
[2.6974 µs 2.7042 µs 2.7132 µs] // previous specialization with peek+next
[563.64 ns 565.92 ns 568.61 ns] // with new specialization

It bothered me a bit too to peek before calling next but I didn't think it would matter that much, thanks!

[Philippe-Cholet]

Just adding that I initially tried to avoid std::mem::swap with (init, head) = self.peekable.fold((init, head), ...); which worked for me but not for the msrv CI test. It did not like assigning to a tuple. The performance was not affected.

[phimuemue]

Nicely done, thanks.

As an aside: Does the mail address from your commits work?

[Philippe-Cholet]

@phimuemue I did not check the mail address for quite some time, but I definitely did this time.