There are many algorithms, which may be more effective on concrete container/range, but there are no functionality to specialize them.
Now, std::lower_bound on map is O(N) (!!!) which is rly scary and easy to miss on code review
* destroy range of jthread
Let some code:
void foo() {
vector<jthread> vec;
(add N jthreads to vec)
}
This is uneffective code. Destructor of 'vec' will execute sequentially .request_stop(). join() for each jthread in it. So, all threads will be exected while we a blocked on .join()
More effective way: call .request_stop() on all jthreads *before* calling .join() in second loop.
We can specialize 'destroy' algorithm for this (all containers use it)
* for_each unseq of map
Consider this code:
auto bar(std::map<int, int>& m, auto fn) {
return std::accumulate(begin(m), end(m), fn, 0);
}
This is also uneffective. Iteration on map is a hard thing, iterating to next element may cost O(logN) time, iterating over all map is ~ O(6*N).
While 'fn' is not dependent on order we can use unsequenced policy:of 'for_each' on map, which is may be specialized to be more effective (for example use recursion instead of iterating and execute in O(1*N) instead of 6*N
Same logic can be applied to non standard ring buffers and other containers
* sort on list
'list' is sortable, it has method 'sort', but std::ranges::sort do not work for it (not random access range). It can be confusing for new programmers and may produce errors in template code. Why we not specialize sort for list?