Here I read that chaining multiple iterators is not -or may not be- as efficient as packing them in more specialized ones.
Ok.
But, isn't the compiler able to spot what is happening with smaller and simpler blocks and convert it to very optimized code? It should be simpler for it.
Yet?
I would be nice to have very simple blocks chained and be done with it, letting the compiler doing the hard work.
The compiler already does all the hard work, so what is your question? Sometimes it makes decisions based on heuristics that manage complex trade-offs. Maybe your chain won't be properly inlined and optimized as well as it could be as a result. Finding global minima is a hard problem.
Yes I have no doubt the compiler is optimizing the code, it is just that having separate filter_map and others, made me wonder if the result would always be the same with filter and map separately for example.
My gut feel is that they'll have roughly the same performance characteristics, with some lambdas lending themselves to optimise better in one situation over another... but as always, don’t just listen to some random guy on the internet. If you care about performance then write a benchmark.
The main benefit of having filter_map is when the alternative is map, then filtering on something the map computed, then another map that's removing the information the filter needed — you use it where you might use if let in sequential code.
This could provide benefits by saving some intermediate steps in the functions you are providing by using one function that can do the work all at once, but it's not inherently an optimization — it can be useful that way, but it is also for writing tidy code.
Generally when using Iterator::chain, it's well known that using the for_each combinator instead of a for loop optimizes better because Chain::for_each is specialized to emit two loops instead of a single loop that checks which half it's in each time.
No, not really. Alice was talking about one specific case. Sometimes, functional iterator chaining style is more readable, or more efficient. Sometimes, loops are. Don't try to shove every procedural algorithm through the same iterator-shaped hole.
But, still, it would be nice for the simplicity of the language if the compiler could consistently erase those corner cases. Multiple small blocks of logic are an opportunity to.
