std::vector<int> v = /* большой массив данных */;
std::sort(std::execution::par, v.begin(), v.end());

// Пример использования SSE-интринсиков (до C++26)
__m128 a = _mm_load_ps(data);
__m128 b = _mm_load_ps(data + 4);
__m128 result = _mm_add_ps(a, b);
_mm_store_ps(output, result);

#pragma omp parallel for
for (int i = 0; i < N; i++) {
    result[i] = heavyComputation(data[i]);
}

tbb::parallel_for(0, N, [&](int i) {
    result[i] = heavyComputation(data[i]);
});

// OpenMP
#pragma omp parallel for
for (int i = 0; i < v.size(); i++) {
    v[i] = process(v[i]);
}
 
// C++17
std::transform(std::execution::par, v.begin(), v.end(), v.begin(), process);

std::vector<double> prices(10000);
std::for_each(std::execution::par, prices.begin(), prices.end(), [](double& price) {
    // ОПАСНО: параллельная запись в соседние элементы может вызвать проблемы из-за
    // возможной переаллокации вектора одним из потоков
    price = calculateNewPrice();
});

// Как разбить данные? Как балансировать нагрузку?
// Стандарт умалчивает, это решает реализация
std::sort(std::execution::par, v.begin(), v.end());

// Обычный код для всех платформ
double dotProduct(const double* a, const double* b, size_t n) {
    double sum = 0.0;
    for (size_t i = 0; i < n; ++i) {
        sum += a[i] * b[i];
    }
    return sum;
}
 
// Специализированный код для процессоров с поддержкой AVX
double dotProductAVX(const double* a, const double* b, size_t n) {
    // Куча низкоуровневого кода с интринсиками
    __m256d sum = _mm256_setzero_pd();
    for (size_t i = 0; i < n; i += 4) {
        __m256d va = _mm256_loadu_pd(a + i);
        __m256d vb = _mm256_loadu_pd(b + i);
        sum = _mm256_add_pd(sum, _mm256_mul_pd(va, vb));
    }
    // И еще больше низкоуровневого кода для получения результата
    // ...
}

// Пример базового использования simd-типа
std::simd<float, 8> a{1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
std::simd<float, 8> b{8.0f, 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f};
std::simd<float, 8> c = a + b; // Векторизованное сложение!

std::simd<int, 4> a{10, 20, 30, 40};
std::simd<int, 4> b{15, 15, 15, 15};
std::simd_mask<int, 4> mask = (a > b); // Результат: {false, true, true, true}
std::simd<int, 4> result = std::where(mask, a, b); // {15, 20, 30, 40}

#define IDX(x, y, z, width, height) ((z) * (width) * (height) + (y) * (width) + (x))
// Использование: pixel = data[IDX(x, y, channel, width, height)];

// Одномерный массив в памяти
std::vector<float> data(width * height * depth);
 
// Интерпретация как трехмерного массива
std::mdspan<float, std::extents<size_t, std::dynamic_extent, std::dynamic_extent, std::dynamic_extent>> 
    volume(data.data(), depth, height, width);
 
// Доступ как к трехмерному массиву
float value = volume[z, y, x];

// Row-major макет (по умолчанию)
std::mdspan<float, std::extents<size_t, height, width>, std::layout_right> img_cpp(data.data());
 
// Column-major макет
std::mdspan<float, std::extents<size_t, height, width>, std::layout_left> img_fortran(data.data());

// Выделение блока 10x10 из большого изображения
auto block = submdspan(image, std::pair{start_y, start_y + 10}, std::pair{start_x, start_x + 10});

// Адаптер для нормализации данных
template<class T>
struct NormalizingAccessor {
  T scale;
  T operator()(T value) const { return value / scale; }
  void set(T& ref, T value) const { ref = value * scale; }
};
 
// Использование с mdspan
auto view = mdspan<float, extents<size_t, h, w>, layout_right, 
                   NormalizingAccessor<float>>(data.data(), {255.0f});

// Паттерн для параллельной обработки
std::array<size_t, 2> strides = {2*n, 2};
auto view = mdspan<int, extents<size_t, n/2, n/2>, layout_stride>
            (data.data(), mapping(extents(n/2, n/2), strides));

// Пример использования simd_vector
std::experimental::simd_vector<float, 16> vec(1000); // 1000 элементов, оптимизированных для SIMD-доступа
std::experimental::native_simd<float> simd_val{1.0f};
vec.fill(simd_val); // Заполнение всех элементов значением 1.0f через SIMD

std::experimental::simd_vector<float, 16> a(1000, 1.0f);
std::experimental::simd_vector<float, 16> b(1000, 2.0f);
std::experimental::simd_vector<float, 16> c(1000);
 
std::transform(a.begin(), a.end(), b.begin(), c.begin(), 
               [](auto x, auto y) { return x + y; });
// Трансформация будет автоматически векторизована!

// Пример операции gather
std::vector<int> indices = {5, 10, 15, 20};
std::experimental::simd<float, 4> values = simd_gather(data_array, indices.data());

// Старый подход
for (size_t i = 0; i < data.size(); ++i) {
    result[i] = std::min(data1[i], data2[i]);
}
 
// Новый подход с C++26
auto simd_result = stdx::min(simd_data1, simd_data2);

auto [minimums, maximums] = stdx::minmax(simd_data1, simd_data2);

// Ограничение значений в диапазоне [0, 255]
auto clamped = stdx::clamp(pixels, stdx::simd<int, 8>(0), stdx::simd<int, 8>(255));

auto red_channel = submdspan(image, std::full_extent, std::full_extent, 0);
auto min_values = stdx::reduce(red_channel, stdx::simd<float>(std::numeric_limits<float>::max()), 
                              [](auto a, auto b) { return stdx::min(a, b); });

stdx::fixed_size_simd<float, 8> a = /* ... */;
stdx::fixed_size_simd<float, 8> b = /* ... */;
stdx::fixed_size_simd<float, 8> result = a + b;

stdx::fixed_size_simd<int, 8> values = /* ... */;
stdx::fixed_size_simd<int, 8> threshold{42};
stdx::fixed_size_simd_mask<int, 8> mask = values > threshold;
values = where(mask, values, stdx::fixed_size_simd<int, 8>{0});

std::vector<int> node_ids = {23, 57, 129, 42, 78, 15, 91, 111};
stdx::fixed_size_simd<float, 8> node_values = 
    stdx::simd_gather<float, 8>(node_data.data(), node_ids.data());

// Было: обычный цикл
float rms = 0.0f;
for (size_t i = 0; i < samples.size(); ++i) {
    rms += samples[i] * samples[i];
}
rms = std::sqrt(rms / samples.size());
 
// Стало: SIMD-оптимизированная версия
using simd_type = stdx::native_simd<float>;
simd_type sum{0.0f};
for (size_t i = 0; i < samples.size(); i += simd_type::size()) {
    simd_type batch = stdx::simd_load<simd_type>(samples.data() + i);
    sum += batch * batch;
}
float rms = std::sqrt(stdx::reduce(sum) / samples.size());

// Выровненная загрузка (быстрее)
auto aligned_data = stdx::simd_aligned_allocator<float>().allocate(size);
auto simd_val = stdx::simd_load<simd_type>(aligned_data);
 
// Невыровненная загрузка (медленнее, но более гибкая)
auto simd_val = stdx::simd_load<simd_type>(regular_data);

std::sort(std::execution::par_unseq, data.begin(), data.end());

auto custom_policy = std::execution::simd.with(
  std::execution::prefer_gpu,
  std::execution::chunk_size(1024)
);
 
std::transform(custom_policy, input.begin(), input.end(), output.begin(), 
              [](auto x) { return std::sqrt(x); });

// Параллельная редукция с использованием SIMD
auto result = std::reduce(std::execution::par_unseq, 
                        data.begin(), data.end(),
                        stdx::native_simd<float>{0.0f},
                        std::plus<>());

std::execution::prefer_parallel_size(8) // Предпочитать разделение на 8 частей

// Расчет экспоненциального скользящего среднего (EMA)
std::vector<double> calculateEMA(const std::vector<double>& prices, int period) {
    std::vector<double> ema(prices.size());
    double multiplier = 2.0 / (period + 1.0);
    
    ema[0] = prices[0]; // Первое значение - просто цена
    for (size_t i = 1; i < prices.size(); ++i) {
        ema[i] = (prices[i] - ema[i-1]) * multiplier + ema[i-1];
    }
    
    return ema;
}

std::vector<double> calculateEMASIMD(const std::vector<double>& prices, int period) {
    std::vector<double> ema(prices.size());
    double multiplier = 2.0 / (period + 1.0);
    
    // Рассчитываем множители для каждой позиции
    std::vector<double> factors(prices.size());
    factors[0] = 1.0;
    for (size_t i = 1; i < prices.size(); ++i) {
        factors[i] = factors[i-1] * (1.0 - multiplier);
    }
    
    // Теперь используем SIMD для параллельных вычислений
    using simd_t = stdx::native_simd<double>;
    for (size_t i = 0; i < prices.size(); i += simd_t::size()) {
        simd_t sum{0.0};
        for (size_t j = 0; j <= i; j += simd_t::size()) {
            size_t k = i - j;
            if (j <= i) {
                simd_t price_batch = stdx::simd_load<simd_t>(&prices[k]);
                simd_t factor_batch = stdx::simd_load<simd_t>(&factors[j]);
                sum += price_batch * factor_batch * multiplier;
            }
        }
        stdx::simd_store(sum, &ema[i]);
    }
    
    return ema;
}

// Свертка изображения с ядром фильтра
void convolution(const std::vector<float>& input, std::vector<float>& output,
                int width, int height, const std::vector<float>& kernel, int kernel_size) {
    int k_radius = kernel_size / 2;
    
    for (int y = k_radius; y < height - k_radius; ++y) {
        for (int x = k_radius; x < width - k_radius; ++x) {
            float sum = 0.0f;
            for (int ky = 0; ky < kernel_size; ++ky) {
                for (int kx = 0; kx < kernel_size; ++kx) {
                    int input_idx = (y + ky - k_radius) * width + (x + kx - k_radius);
                    int kernel_idx = ky * kernel_size + kx;
                    sum += input[input_idx] * kernel[kernel_idx];
                }
            }
            output[y * width + x] = sum;
        }
    }
}

void convolutionSIMD(std::mdspan<const float, std::extents<size_t, std::dynamic_extent, std::dynamic_extent>> input,
                    std::mdspan<float, std::extents<size_t, std::dynamic_extent, std::dynamic_extent>> output,
                    std::mdspan<const float, std::extents<size_t, std::dynamic_extent, std::dynamic_extent>> kernel) {
    int height = input.extent(0);
    int width = input.extent(1);
    int k_height = kernel.extent(0);
    int k_width = kernel.extent(1);
    int k_radius_y = k_height / 2;
    int k_radius_x = k_width / 2;
    
    using simd_t = stdx::native_simd<float>;
    const int simd_width = simd_t::size();
    
    for (int y = k_radius_y; y < height - k_radius_y; ++y) {
        // Обрабатываем по simd_width пикселей за раз
        for (int x = k_radius_x; x < width - k_radius_x; x += simd_width) {
            std::array<simd_t, 1> sum = {simd_t(0.0f)};
            
            for (int ky = 0; ky < k_height; ++ky) {
                for (int kx = 0; kx < k_width; ++kx) {
                    float k_val = kernel(ky, kx);
                    simd_t k_simd(k_val);
                    
                    // Загружаем блок пикселей
                    simd_t input_simd;
                    for (int sx = 0; sx < simd_width; ++sx) {
                        input_simd[sx] = input(y + ky - k_radius_y, x + sx + kx - k_radius_x);
                    }
                    
                    sum[0] += input_simd * k_simd;
                }
            }
            
            // Сохраняем результат
            for (int sx = 0; sx < simd_width; ++sx) {
                if (x + sx < width - k_radius_x)
                    output(y, x + sx) = sum[0][sx];
            }
        }
    }
}

// Наивная попытка ускорения - может оказаться медленнее!
stdx::native_simd<float> process(stdx::native_simd<float> data) {
  // Операции, которые плохо векторизуются
  return data * stdx::sin(data) / (stdx::cos(data) + 0.01f);
}

#ifdef DEBUG_SIMD
  using debug_simd_t = stdx::fixed_size_simd<float, 4, stdx::simd_abi::scalar>;
#else
  using debug_simd_t = stdx::native_simd<float>;
#endif

// Проверка, что операция безопасна для параллельного выполнения
#ifdef PARALLEL_CHECK
  std::atomic<bool> accessing{false};
  bool was_accessing = accessing.exchange(true);
  assert(!was_accessing && "Parallel access detected!");
  // Операция с SIMD-данными
  accessing = false;
#else
  // Обычное выполнение операции
#endif

template<typename T>
bool is_aligned(const T* ptr, size_t alignment) {
  return reinterpret_cast<uintptr_t>(ptr) % alignment == 0;
}
 
// Использование
if (!is_aligned(data.data(), 32)) {
  std::cerr << "Warning: Unaligned data may degrade SIMD performance" << std::endl;
}

void debug_mask(const stdx::native_simd_mask<float>& mask) {
  std::cout << "Mask: ";
  for (size_t i = 0; i < mask.size(); ++i) {
    std::cout << (mask[i] ? '1' : '0');
  }
  std::cout << std::endl;
}

// До C++20 это было больно
std::vector<int> result;
for (const auto& sub_vec : nested_vectors) {
    for (int val : sub_vec) {
        if (val % 2 == 0) {
            result.push_back(val * val);
        }
    }
}
 
// C++20+ с ranges
auto result = nested_vectors 
    | std::ranges::views::join 
    | std::ranges::views::filter([](int n) { return n % 2 == 0; })
    | std::ranges::views::transform([](int n) { return n * n; });

std::vector<std::vector<int>> nested{{1, 2}, {3, 4, 5}, {6, 7}};
auto joined = std::views::join(nested);
 
for (int i : joined) 
    std::println(i); // выведет 1 2 3 4 5 6 7

std::vector<std::string> words { "Hello", "World", "Coding" };
 
// вместо:
std::map<char, int> freq;
for (auto &w : words)
    for (auto &c : w)
        freq[::tolower(c)]++;
 
// с join:
std::map<char, int> freq;
for (auto &c : words | std::views::join)
    freq[::tolower(c)]++;

std::vector<std::string_view> words{
    "The", "C++", "ranges", "library"
};
 
auto words_up = words | std::views::transform([](std::string_view word) {
    std::string result(word);
    for (char& c : result) 
        c = std::toupper(static_cast<unsigned char>(c));
    return result;
});
 
auto joined = std::views::join_with(words_up, std::string_view(" "));
 
for (auto c : joined) 
    std::cout << c; // Выведет: THE C++ RANGES LIBRARY

std::string result;
for (size_t i = 0; i < words.size(); ++i) {
    result += words[i];
    if (i < words.size() - 1)
        result += " ";
}

std::vector<std::string> v1{"world", "hi"};
std::vector<std::string> v2 { "abc", "xyz" };
std::string arr[]{"one", "two", "three"};
 
auto v1_rev = v1 | std::views::reverse;
auto concat = std::views::concat(v1_rev, v2, arr);
 
concat[0] = "hello"; // доступ и модификация по индексу
 
for (auto& elem : concat)
    std::print("{} ", elem); // hello world abc xyz one two three

struct Transaction {
std::string type;
double amount;
};
 
// Банковские транзакции
std::vector<Transaction> bank_transactions{
   {"Deposit", 100.0}, 
   {"Withdraw", 50.0}, 
   {"Deposit", 200.0}
};
 
// Транзакции по кредитной карте
std::list<Transaction> credit_card_transactions{
    {"Charge", 75.0}, {"Payment", 50.0}
};
 
// Фильтруем только крупные транзакции из каждого источника
auto filtered_bank = bank_transactions 
    | std::views::filter([](const Transaction& t) {
        return t.amount >= 100.0;
    });
 
auto filtered_credit = credit_card_transactions 
    | std::views::filter([](const Transaction& t) {
        return t.amount > 60.0;
    });
 
// Объединяем отфильтрованные транзакции
auto all_transactions = std::views::concat(filtered_bank, filtered_credit);
 
// Теперь можем работать со всеми крупными транзакциями как с единым диапазоном
for (const auto& t : all_transactions)
    std::println("{} - {}$", t.type, t.amount);

// Традиционный подход
void traditional_join(const std::vector<std::vector<int>>& nested) {
    std::vector<int> result;
    for (const auto& inner : nested) {
        for (int val : inner) {
            result.push_back(val);
        }
    }
    return result;
}
 
// Подход с ranges
auto ranges_join(const std::vector<std::vector<int>>& nested) {
    return nested | std::views::join;
}

std::vector<std::vector<int>> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
auto flattened = matrix | std::views::join;
// flattened содержит 1, 2, 3, 4, 5, 6, 7, 8, 9

std::vector<std::vector<std::vector<int>>> volume = {
    {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}},
    {{{9, 10}, {11, 12}}, {{13, 14}, {15, 16}}}
};
 
auto flattened = volume 
    | std::views::join    // Убирает первый уровень вложенности
    | std::views::join;   // Убирает второй уровень вложенности
// flattened содержит 1, 2, 3, 4, 5, 6, ..., 16

std::vector<std::vector<int>> nested = {{}, {1, 2}, {}, {3, 4}, {}};
auto joined = nested | std::views::join;
// joined содержит 1, 2, 3, 4

std::vector<std::vector<int>> nested = {{}, {1, 2}, {}, {3, 4}, {}};
auto joined = nested | std::views::join_with(0);
// joined содержит 1, 2, 0, 3, 4

std::vector<int> v1 = {1, 2};
std::vector<int> v2 = {};
std::vector<int> v3 = {3, 4};
auto concatenated = std::views::concat(v1, v2, v3);
// concatenated содержит 1, 2, 3, 4

std::vector<std::string> split(const std::string& text, char delimiter) {
    std::vector<std::string> result;
    std::stringstream ss(text);
    std::string item;
    while (std::getline(ss, item, delimiter)) {
        if (!item.empty()) {
            result.push_back(item);
        }
    }
    return result;
}

#include <print>
#include <ranges>
#include <string_view>
 
int main() {
    using namespace std::string_view_literals;
    
    constexpr auto text = "C++ is powerful and elegant"sv;
    
    for (auto part : std::views::split(text, ' '))
        std::print("'{}' ", std::string_view(part));
}

constexpr auto text = "C++breakisbreakpowerfulbreakandbreakelegant"sv;
 
for (auto part : std::views::split(text, "break"sv))
    std::print("'{}' ", std::string_view(part));

using Point = std::pair<int, int>;
 
std::vector<Point> path = {
    {0, 0}, {1, 1}, {-1, -1}, // маркер: {-1, -1}
    {2, 2}, {3, 3}, {-1, -1},
    {4, 4}, {5, 5}
};
 
for (auto segment : std::views::split(path, Point{-1, -1}))
    std::print("Сегмент: {}\n", segment);

Сегмент: [(0, 0), (1, 1)]
Сегмент: [(2, 2), (3, 3)]
Сегмент: [(4, 4), (5, 5)]

#include <print>
#include <ranges>
#include <vector>
 
int main() {
    std::vector<int> data{1, 2, 3, 4, 5, 6, 7, 8};
    
    for (auto chunk : data | std::views::chunk(3))
        std::print("{}\n", chunk);
}

[ 1 2 3 ]
[ 4 5 6 ]
[ 7 8 ]

#include <print>
#include <ranges>
#include <sstream>
#include <vector>
 
int main() {
    std::istringstream stream{"AB CD EF 12 34 56 78 95 FF"};
    
    auto bytes = std::ranges::istream_view<std::string>(stream);
    
    for (auto packet : bytes | std::views::chunk(4))
        std::print("Пакет: {}\n", packet);
}

Пакет: ["AB", "CD", "EF", "12"]
Пакет: ["34", "56", "78", "95"]
Пакет: ["FF"]

#include <print>
#include <ranges>
#include <vector>
 
int main() {
    std::vector<int> values{1, 3, 5, 2, 4, 6, 7, 9, 8};
    
    for (auto group : values | std::views::chunk_by([](int a, int b) {
        return (a % 2) == (b % 2); // Одинаковая четность
    })) {
        std::print("размер {}, {}\n", group.size(), group);
    }
}

размер 3, [1, 3, 5]
размер 3, [2, 4, 6]
размер 2, [7, 9]
размер 1, [8]

constexpr auto text = "C++ is powerful. Ranges are elegant. This is fun!"sv;
 
for (auto sentence : text | std::views::chunk_by([](char a, char b) {
    return a != '.' && a != '!' && a != '?';
})) {
    // Удаляем лишние пробелы и печатаем только осмысленные группы
    auto view = std::string_view(&*sentence.begin(), std::ranges::distance(sentence));
    view = view.substr(0, view.find_first_of(".!?") + 1);
    if (!view.empty() && view.size() > 1)
        std::print("Предложение: [{}]\n", view);
}

struct Trade {
    std::string symbol;
    double price;
    int volume;
    std::chrono::system_clock::time_point timestamp;
};
 
std::vector<Trade> trades = /* ... */;
 
// Группируем сделки по символу
auto trades_by_symbol = trades | std::views::chunk_by([](const Trade& a, const Trade& b) {
    return a.symbol == b.symbol;
});
 
// Обрабатываем каждую группу
for (auto group : trades_by_symbol) {
    process_symbol_group(group);
}

std::string csv_line = "field1,\"field2,with,commas\",field3";
 
// Это не сработает корректно из-за запятых внутри кавычек
auto simple_split = csv_line | std::views::split(',');
 
// Нужен более сложный подход
auto tokenize_csv = [](std::string_view line) {
    std::vector<std::string> result;
    bool in_quotes = false;
    std::string current_field;
    
    for (char c : line) {
        if (c == '"') {
            in_quotes = !in_quotes;
        } else if (c == ',' && !in_quotes) {
            result.push_back(current_field);
            current_field.clear();
        } else {
            current_field += c;
        }
    }
    
    if (!current_field.empty()) {
        result.push_back(current_field);
    }
    
    return result;
};

std::string utf8_text = "привет, мир!";
auto words = utf8_text | std::views::split(' ');

for (auto part : std::views::split(text, ' '))
    std::print("'{}' ", std::string_view(part));

template <typename Range>
auto regex_split(Range&& r, const std::regex& pattern) {
    return std::forward<Range>(r) | std::views::transform([&pattern](auto&& item) {
        using std::regex_token_iterator;
        using value_type = std::decay_t<decltype(item)>;
        
        if constexpr (std::is_convertible_v<value_type, std::string_view>) {
            std::string_view sv = item;
            std::string s(sv);
            return std::vector<std::string>(
                regex_token_iterator<std::string::iterator>(s.begin(), s.end(), pattern, -1),
                regex_token_iterator<std::string::iterator>()
            );
        } else {
            // Для нестроковых типов просто возвращаем исходный элемент
            return std::vector<value_type>{item};
        }
    }) | std::views::join;
}

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
auto result = numbers
 | std::views::filter([](int n) { return n % 2 == 0; })  // Только четные
 | std::views::transform([](int n) { return n * n; })    // Возведение в квадрат
 | std::views::take(3);                                 // Только первые 3 элемента
 
// result содержит {4, 16, 36}

auto expensive_op = [](int x) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Имитация тяжелой операции
    return x * 2;
};
 
auto view = numbers 
 | std::views::transform(expensive_op)
 | std::views::filter([](int n) { return n > 5; });
 
// Первый проход
for (auto val : view) {
    std::cout << val << " ";
}
 
// Второй проход
int sum = 0;
for (auto val : view) {
    sum += val;
}

auto intermediate = numbers 
 | std::views::transform(expensive_op)
 | std::ranges::to<std::vector>(); // C++23 материализация
 
auto view = intermediate | std::views::filter([](int n) { return n > 5; });
 
// Теперь expensive_op вызывается только один раз для каждого элемента

auto get_filtered() {
    std::vector<int> local_data = {1, 2, 3, 4, 5};
    return local_data | std::views::filter([](int x) { return x > 2; });
}
 
void use_filtered() {
    auto filtered = get_filtered();
    for (int x : filtered) {  // Упс! Неопределенное поведение!
        std::cout << x << " ";
    }
}

   auto get_filtered() {
       std::vector<int> local_data = {1, 2, 3, 4, 5};
       auto filtered = local_data | std::views::filter([](int x) { return x > 2; });
       return filtered | std::ranges::to<std::vector>();
   }

   auto get_filtered() {
       auto data = std::make_shared<std::vector<int>>(std::vector{1, 2, 3, 4, 5});
       return std::views::owning_view(*data) | std::views::filter([data](int x) { return x > 2; });
   }

   auto apply_filter(std::ranges::range auto& r) {
       return r | std::views::filter([](int x) { return x > 2; });
   }

std::vector<int> big_data(1'000'000);
// Заполняем данными...
 
auto result = std::ranges::sort(big_data | std::views::filter([](int x) { return x > 0; }),
                               std::execution::par); // Параллельная сортировка

auto positive = big_data 
 | std::views::filter([](int x) { return x > 0; })
 | std::ranges::to<std::vector>();
 
std::ranges::sort(positive, std::execution::par);

auto time_series = load_data();
 
// Повторяющееся преобразование
auto common_transform = std::views::transform([](auto& point) {
    return process_point(point); // Дорогая операция
});
 
// Разные фильтры с одинаковым преобразованием
auto dataset1 = time_series 
 | std::views::filter([](auto& p) { return p.region == "North"; })
 | common_transform;
 
auto dataset2 = time_series 
 | std::views::filter([](auto& p) { return p.region == "South"; })
 | common_transform;

auto cached_data = time_series
 | std::views::transform([](auto& point) {
     static std::map<decltype(point.id), decltype(process_point(point))> cache;
     auto it = cache.find(point.id);
     if (it != cache.end())
         return it->second;
     auto result = process_point(point);
     cache[point.id] = result;
     return result;
 })
 | std::ranges::to<std::vector>();
 
// Теперь используем кэшированные данные
auto dataset1 = cached_data | std::views::filter([](auto& p) { return p.region == "North"; });
auto dataset2 = cached_data | std::views::filter([](auto& p) { return p.region == "South"; });

cppcoro::generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield b;
        auto next = a + b;
        a = b;
        b = next;
    }
}
 
void use_fibonacci() {
    auto fib = fibonacci()
     | std::views::take(10)  // Первые 10 чисел Фибоначчи
     | std::views::transform([](int x) { return x * x; });
     
    for (auto val : fib) {
        std::cout << val << " ";
    }
}

// Генератор событий
cppcoro::generator<Event> event_stream() {
    while (true) {
        auto event = wait_for_next_event(); // Блокирующий вызов, ожидающий событие
        co_yield event;
    }
}
 
// Использование с ranges
auto important_events = event_stream()
    | std::views::filter([](const Event& e) { return e.priority > 5; })
    | std::views::take_while([](const Event& e) { return !e.is_shutdown_signal; });
 
for (const auto& event : important_events) {
    handle_important_event(event);
}

template <std::ranges::input_range R>
requires std::ranges::view<R> && std::is_arithmetic_v<std::ranges::range_value_t<R>>
class offset_view : public std::ranges::view_interface<offset_view<R>> {
private:
    R base_ = {};
    std::ranges::range_value_t<R> offset_ = 0;
    
    template <bool Const>
    class iterator {
        // ... детали реализации итератора
    };
 
public:
    offset_view() = default;
    
    offset_view(R base, std::ranges::range_value_t<R> offset)
        : base_(std::move(base)), offset_(offset) {}
    
    auto begin() { return iterator<false>(std::ranges::begin(base_), offset_); }
    auto end() { return sentinel<false>(std::ranges::end(base_)); }
    
    // ... остальные методы
};
 
// Шаблон конвейерного адаптера
inline constexpr auto offset(auto&& value) {
    return std::views::view_closure(
        [value = std::forward<decltype(value)>(value)](auto&& r) {
            return offset_view(std::forward<decltype(r)>(r), value);
        });
}

std::vector<int> nums = {1, 2, 3, 4, 5};
auto result = nums | std::views::filter([](int x) { return x % 2 == 1; })
                   | offset(10)
                   | std::views::transform([](int x) { return x * 2; });
// result содержит {22, 26, 30}

template <typename T>
auto debug_view(std::string_view label = "Debug") {
    return std::views::transform([label](T&& item) {
        std::cerr << label << ": " << item << '\n';
        return std::forward<T>(item);
    });
}

auto result = numbers
    | std::views::filter([](int n) { return n % 2 == 0; })
    | debug_view<int>("After filter")
    | std::views::transform([](int n) { return n * n; })
    | debug_view<int>("After transform");

std::ifstream log_file("server.log");
std::string line;
std::vector<std::string> error_requests;
 
// Традиционный подход
while (std::getline(log_file, line)) {
    if (line.find("HTTP 404") != std::string::npos) {
        std::stringstream ss(line);
        std::string timestamp, ip, method, url, status, size;
        ss >> timestamp >> ip >> method >> url >> status >> size;
        error_requests.push_back(url);
    }
}
 
// Подход с ranges (C++23)
auto error_lines = std::ranges::istream_view<std::string>(log_file)
    | std::views::filter([](const std::string& line) { 
        return line.find("HTTP 404") != std::string::npos; 
    });
 
auto parsed_errors = error_lines 
    | std::views::transform([](const std::string& line) {
        std::stringstream ss(line);
        std::string timestamp, ip, method, url, status, size;
        ss >> timestamp >> ip >> method >> url >> status >> size;
        return url;
    });
 
auto result = parsed_errors | std::ranges::to<std::vector>();

struct Record {
    std::string name;
    int age;
    std::string city;
};
 
std::vector<Record> parse_csv(const std::string& file_path) {
    std::ifstream file(file_path);
    std::string header;
    std::getline(file, header); // Пропускаем заголовок
    
    auto lines = std::ranges::istream_view<std::string>(file);
    
    auto records = lines 
        | std::views::transform([](const std::string& line) {
            auto parts = line | std::views::split(',')
                | std::views::transform([](auto&& part) {
                    return std::string(part.begin(), part.end());
                })
                | std::ranges::to<std::vector>();
            
            return Record{
                parts[0],
                std::stoi(parts[1]),
                parts[2]
            };
        })
        | std::views::filter([](const Record& r) { return r.age > 0; }) // Валидация
        | std::ranges::to<std::vector>();
    
    return records;
}

using Pixel = std::array<uint8_t, 3>; // RGB
using Image = std::vector<Pixel>;
 
Image blur_image(const Image& image, int width, int height, int kernel_size) {
    auto get_pixel = [&](int x, int y) -> const Pixel& {
        x = std::clamp(x, 0, width - 1);
        y = std::clamp(y, 0, height - 1);
        return image[y * width + x];
    };
    
    auto pixel_indices = std::views::iota(0, width * height);
    
    auto blurred_pixels = pixel_indices
        | std::views::transform([&](int idx) {
            int x = idx % width;
            int y = idx / width;
            
            std::array<double, 3> sum = {0, 0, 0};
            int count = 0;
            
            auto offsets = std::views::iota(-kernel_size/2, kernel_size/2 + 1);
            auto neighbor_pixels = std::views::cartesian_product(offsets, offsets)
                | std::views::transform([&](auto&& p) {
                    auto [dx, dy] = p;
                    return get_pixel(x + dx, y + dy);
                });
            
            for (const auto& p : neighbor_pixels) {
                sum[0] += p[0];
                sum[1] += p[1];
                sum[2] += p[2];
                count++;
            }
            
            return Pixel{
                static_cast<uint8_t>(sum[0] / count),
                static_cast<uint8_t>(sum[1] / count),
                static_cast<uint8_t>(sum[2] / count)
            };
        })
        | std::ranges::to<Image>();
    
    return blurred_pixels;
}

std::vector<double> calculate_moving_average(const std::vector<double>& prices, int window) {
    return std::views::iota(0, static_cast<int>(prices.size() - window + 1))
        | std::views::transform([&](int start) {
            auto window_view = prices 
                | std::views::drop(start) 
                | std::views::take(window);
            
            double sum = 0.0;
            int count = 0;
            for (double price : window_view) {
                sum += price;
                count++;
            }
            
            return sum / count;
        })
        | std::ranges::to<std::vector>();
}

enum class TokenType { 
    LeftBrace, RightBrace, LeftBracket, RightBracket, 
    Colon, Comma, String, Number, True, False, Null 
};
 
struct Token {
    TokenType type;
    std::string value;
};
 
std::vector<Token> tokenize_json(std::string_view json) {
    auto is_whitespace = [](char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; };
    
    // Пропускаем пробелы
    auto non_whitespace = json | std::views::filter([&](char c) { return !is_whitespace(c); });
    
    std::vector<Token> tokens;
    
    auto it = non_whitespace.begin();
    auto end = non_whitespace.end();
    
    while (it != end) {
        char c = *it++;
        
        switch (c) {
            case '{': tokens.push_back({TokenType::LeftBrace, "{"}); break;
            case '}': tokens.push_back({TokenType::RightBrace, "}"}); break;
            case '[': tokens.push_back({TokenType::LeftBracket, "["}); break;
            case ']': tokens.push_back({TokenType::RightBracket, "]"}); break;
            case ':': tokens.push_back({TokenType::Colon, ":"}); break;
            case ',': tokens.push_back({TokenType::Comma, ","}); break;
            
            case '"': {
                // Строки обрабатываем отдельно
                auto start = it;
                while (it != end && *it != '"') ++it;
                tokens.push_back({TokenType::String, std::string(start, it)});
                if (it != end) ++it; // Пропускаем закрывающую кавычку
                break;
            }
            
            default:
                // Числа и ключевые слова требуют более сложной обработки...
                // (упрощено для примера)
                if (std::isdigit(c) || c == '-') {
                    auto start = it - 1;
                    while (it != end && (std::isdigit(*it) || *it == '.')) ++it;
                    tokens.push_back({TokenType::Number, std::string(start, it)});
                }
                break;
        }
    }
    
    return tokens;
}