#include <range/v3/view/transform.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/map.hpp>
#include <range/v3/view/cycle.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/iterator/stream_iterators.hpp>

#include <iostream>
#include <vector>
#include <set>
#include <map>

using namespace ranges;

auto some_algo()
{
    // некоторый алгоритм который ничего не знает о структурах данных и работает с произвольной последовательностью
    return view::transform( []( auto x ){ return x * 2; } ) |                // умножаем числа последовательности на 2
           view::filter( []( auto x ){ return x >= 10 && x <= 100; } ) |     // фильтруем числа не входящие в диапазон [10, 100]
           view::take( 4 );                                                  // берем не более 4 чисел из оставшихся после фильтрации
}

template <typename R>
void print( R&& range ) 
{
    // печать на консоль произвольной последовательности
    copy( range, make_ostream_joiner( std::cout, "," ) );
    std::cout << '\n';
}

int main()
{
    std::vector<int> vs = { 5, 10, 15, 20, 25 };
    print( vs );                // печатаем содержимое vs
    print( vs | some_algo() );  // печатаем последовательность полученную после применения алгоритма some_algo к vs

    std::set<double> ss = { 15.5, 30.0, 42.4242, 100.0 };
    print( ss | some_algo() );  // аналогично для ss

    std::map<int, int> m = { { 10, 20 }, { 30, 40 }, { 50, 60 } };
    auto some_range = m | view::keys        // берем последовательность ключей мапы ( 10, 30, 50 )
                        | some_algo()       // применяем наш алгоритм
                        | view::cycle       // зацикливаем получившуюся последовательно
                        | view::take( 10 ); // берем из зацикленной ( бесконечной ) последовательности первые 10 элементов

    print( some_range );

    for( auto v : m | view::values | view::reverse )  // обходим в цикле значения мапы в обратном порядке
    {
        std::cout << v << ' ';
    }

}

/*
output:
5,10,15,20,25
10,20,30,40
31,60,84.8484
20,60,100,20,60,100,20,60,100,20
60 40 20
*/

Некоторые из ответов вида «весь фидбек будет проигнорирован, если он не оформлен в виде документа, представленного на собрании комитета C++», которые я видел в последнее время не кажутся мне продуктивным подходом

fn triples(n: u32) -> impl Iterator<Item = (u32, u32, u32)> {
    (0..n).flat_map(move |z| 
        (1..z).flat_map(move |x| 
            (x..z).map(move |y| 
                (x, y, z)
            )
        )
    )
    .filter(|(x, y, z)| x*x + y*y == z*z)
}

Основные идеи:
1.В C++ очень важно время компиляции,
2.Производительность сборки без оптимизаций тоже важна,
3.Когнитивная нагрузка ещё важней. Вот по этому пункту особо распространяться не буду,
но если язык программирования заставляет меня чувствовать себя тупым, вряд ли я его буду использовать или тем более — любить. C++ делает это со мной постоянно.

/* main.cpp */ 

#include <iostream>

using namespace std;

template <class T,class S>
struct Test
 {
  Test(T,S) {}
 };

/* main() */

int main()
 {
  Test t1(1,2);

  Test<double> t2(1,2);

  return 0;
 }

KP>

fn triples(n: u32) -> impl Iterator<Item = (u32, u32, u32)> {
KP>    (0..n).flat_map(move |z| 
KP>        (1..z).flat_map(move |x| 
KP>            (x..z).map(move |y| 
KP>                (x, y, z)
KP>            )
KP>        )
KP>    )
KP>    .filter(|(x, y, z)| x*x + y*y == z*z)
KP>}
KP>

[(x, y, z) | z <- [0..n-1], x <- [1..z-1], y <- [x..z-1], x*x + y*y == z*z]

auto triples = ints(1)      >>= [ ](int z) { return
               ints(1, z+1) >>= [=](int x) { return
               ints(x, z+1) >>= [=](int y) { return
   yield_if(x*x + y*y == z*z, std::make_tuple(x, y, z)); };}; };

Я работаю, возможно, над самым популярным в мире игровым движком, которым пользуются миллионы, и часть из них любит говорить, прямо или непрямо, насколько он отвратительный.