Substitute logical folds to any() or all()

[totikom]

What it does

Some uses of .fold() can be substituted to existing methods on iterators like .all() and .any().

Categories (optional)

• Kind: clippy::complexity

What is the advantage of the recommended code over the original code

• Dramatically improves code readability
• In average work faster, as .any() and .all() are short-circuiting (see the docs)

Drawbacks

None.

Examples

all:

some_iterator.fold(true, | acc, x| {
    acc & x
});

Could be written as:

some_iterator.all(|x| x);

any:

some_iterator.fold(false, | acc, x| {
    acc | x
});

Could be written as:

some_iterator.any(|x| x);

More over, rustfmt will remove curly brackets in the original code, so closure in the .any() case will be formatted to completely unreadable and confusing |acc, x| acc | x

[totikom]

Actually, the things are a bit more complicated.
.fold() will always consume the whole iterator, while .all() (and .any()) exits after the first false (or true).
If the iterator has side-effects, the behavior of the original and the linted code may differ.

Maybe it should be moved to clippy::perf with warning about side-effects.

[totikom]

And one more note:
It is highly possible, that the iterator over bools was obtained via .map().
In that case:

some_iterator.map(| item | {
// a closure which returns bool
})
.fold(false, | acc, x| {
    acc | x
});

Could be written as:

some_iterator.any(| item | {
// a closure which returns bool
});

Or:

some_iterator.map(| item | {
// a closure which returns bool
})
.fold(true, | acc, x| {
    acc & x
});

Could be written as:

some_iterator.all(| item | {
// a closure which returns bool
});

[camsteffen]

Isn't this unnecessary_fold?

[totikom]

Actually, it is. Didn't checked that.
I don't understand, if this lint is currently active?
I've created this issue, because clippy didn't show any warnings even with pedantic flag.

[camsteffen]

You are using bitwise operators & and | instead of logical operators && and ||. I'll keep this open since we probably should lint that. We could either lint any unnecessary bitwise operators, or just enhance unnecessary_fold, or both! But I think I'd prefer just adding a new lint bitwise_bool.

[totikom]

Yes, bitwise_bool sounds like an important lint.

[arya-k]

@rustbot claim