std::span в C++: Подпредставлени­я и срезы

std::vector<double> temperature_readings(365); // данные за весь год
// заполнение данных...
 
// Создаем span для летних месяцев (с 152-го по 243-й день)
std::span summer_temps(temperature_readings.data() + 152, 92);
 
// Теперь можем работать только с летними данными
double average = compute_average(summer_temps);

template<class T, size_t Extent = std::dynamic_extent>
class span {
    T* ptr_;                  // Указатель на данные
    size_t size_;             // Размер последовательности
    // ...
};

std::vector<int> data = {1, 2, 3, 4, 5};
std::span<int> mySpan(data);  // Создаём span над вектором
 
// Теперь mySpan представляет собой вид на data
// Можем работать с элементами через span
mySpan[0] = 10;  // Изменит первый элемент в исходном векторе!

// Раньше нам приходилось писать так:
void processArray(int* arr, size_t size);
void processVector(const std::vector<int>& vec);
 
// Теперь можно просто:
void process(std::span<const int> data);

// Динамический размер, определяемый во время выполнения
std::span<int> dynamicSpan(arr, 10);
 
// Статический размер, известный на этапе компиляции
std::span<int, 5> staticSpan(arr);

std::span<int> createDangerousSpan() {
    std::vector<int> tempVector = {1, 2, 3};
    return std::span(tempVector);  // ОПАСНО! tempVector будет уничтожен
}
 
// При использовании вернувшегося span произойдет обращение к освобожденной памяти

std::vector<int> mutableData = {1, 2, 3};
const std::vector<int> constData = {4, 5, 6};
 
std::span<int> mutableSpan(mutableData);             // Изменяемый span на изменяемые данные
std::span<const int> constDataSpan(mutableData);     // Изменяемый span на неизменяемые данные
std::span<const int> constDataSpan2(constData);      // Изменяемый span на неизменяемые данные
const std::span<int> constSpan(mutableData);         // Неизменяемый span на изменяемые данные

std::span<int> getTemporarySpan() {
    std::vector<int> local_data = {1, 2, 3}; // Локальный вектор
    return std::span(local_data); // ОШИБКА: local_data будет уничтожен после выхода из функции
}

void processWithSpan(std::span<int> data) {
    // Безопасно использовать data здесь
    for (auto& value : data) {
        value *= 2;
    }
}
 
int main() {
    std::vector<int> persistent_data = {1, 2, 3};
    processWithSpan(persistent_data); // Корректно: вектор существует дольше span
    return 0;
}

std::vector<int> values = {1, 2, 3, 4, 5};
std::span<int> valuesSpan(values);
 
// Использование со стандартными алгоритмами
std::sort(valuesSpan.begin(), valuesSpan.end());
auto sum = std::accumulate(valuesSpan.begin(), valuesSpan.end(), 0);

void processItems(std::span<Item> items) {
    // Передача по значению — эффективно, так как span очень мал
}
 
std::vector<Item> allItems = loadItems();
processItems(allItems); // Никаких проблем с производительностью

void analyzeData(std::span<const double> data) {
    // Гарантированно не изменяет данные
    double average = 0.0;
    for (const auto& value : data) {
        average += value;
    }
    average /= data.size();
    // data[0] = 0.0; // Ошибка компиляции
}

#include <span>
#include <iostream>
 
int main() {
    int data[] = {1, 2, 3, 4, 5, 6, 7, 8};
    std::span<int> mySpan(data);  // Полный span для массива
    
    // Создание подпредставления из первых 3 элементов
    std::span<int> firstThree = mySpan.first(3);
    
    std::cout << "Первые три элемента: ";
    for (int value : firstThree) {
        std::cout << value << " ";
    }
    std::cout << "\n";
    return 0;
}

#include <span>
#include <iostream>
 
int main() {
    int data[] = {10, 20, 30, 40, 50, 60, 70, 80};
    std::span<int> mySpan(data);  // Полный span для массива
    
    // Создание подпредставления из последних 4 элементов
    std::span<int> lastFour = mySpan.last(4);
    
    std::cout << "Последние четыре элемента: ";
    for (int value : lastFour) {
        std::cout << value << " ";
    }
    std::cout << "\n";
    return 0;
}

#include <span>
#include <iostream>
 
int main() {
    int data[] = {5, 10, 15, 20, 25, 30, 35, 40, 45};
    std::span<int> mySpan(data);  // Полный span для массива
    
    // Создание подпредставления из 4 элементов, начиная с индекса 2
    std::span<int> midFour = mySpan.subspan(2, 4);
    
    std::cout << "Четыре элемента с индекса 2: ";
    for (int value : midFour) {
        std::cout << value << " ";
    }
    std::cout << "\n";
    return 0;
}

std::span<int> fullSpan = /* ... */;
size_t half_size = fullSpan.size() / 2;
std::span<int> firstHalf = fullSpan.first(half_size);
std::span<int> secondHalf = fullSpan.subspan(half_size);

std::span<int> fullSpan = /* ... */;
std::span<int> middlePortion = fullSpan.subspan(1, fullSpan.size() - 2);

std::span<int> mySpan = /* span из 5 элементов */;
auto invalid = mySpan.first(10);  // Может привести к ошибке во время выполнения

int data[] = {1, 2, 3, 4, 5};
std::span<int> fullSpan(data);
std::span<int> subSpan = fullSpan.first(3);
 
subSpan[0] = 10;  // Изменяет data[0] и fullSpan[0]
 
std::cout << fullSpan[0];  // Выведет 10

const std::vector<int> data = {1, 2, 3, 4, 5};
std::span<const int> constSpan(data);
std::span<const int> subSpan = constSpan.first(3);
 
// subSpan[0] = 10;  // Ошибка компиляции - нельзя изменить константные данные

std::vector<int> mutableData = {1, 2, 3, 4, 5};
std::span<const int> constView(mutableData);
// constView[0] = 10;  // Ошибка компиляции - через этот span нельзя менять данные

std::span<int> mutableSpan = /* ... */;
std::span<const int> constSpan = mutableSpan;  // OK, неявное преобразование

std::span<const int> constSpan = /* ... */;
std::span<int> mutableSpan = constSpan;  // Ошибка компиляции

struct Point {
    int x, y;
};
 
std::vector<Point> points = {{1, 2}, {3, 4}, {5, 6}};
std::span<Point> pointsSpan(points);
 
// Создание подпредставления для доступа к полю x каждой точки
// Это требует глубокого понимания и осторожности!
std::span<int> x_coordinates(
    &pointsSpan[0].x,  // Адрес первого x
    pointsSpan.size()  // Количество точек
);

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::span<int> fullSpan(data);
 
// Создаем подпредставление из элементов с 3 по 8
std::span<int> midSection = fullSpan.subspan(2, 6);  // {3, 4, 5, 6, 7, 8}
 
// Создаем подпредставление из последних 3 элементов midSection
std::span<int> lastThree = midSection.last(3);  // {6, 7, 8}

template <typename T>
void processSliding(std::span<T> data, size_t window_size) {
    for (size_t i = 0; i + window_size <= data.size(); ++i) {
        std::span<T> window = data.subspan(i, window_size);
        // Обработка окна
        process(window);
    }
}

template <typename T>
void quickSort(std::span<T> s) {
    if (s.size() <= 1) return;
    
    // Выбираем опорный элемент и перемещаем элементы
    T pivot = s[s.size() / 2];
    size_t i = 0, j = s.size() - 1;
    
    while (i <= j) {
        while (s[i] < pivot) i++;
        while (s[j] > pivot) j--;
        
        if (i <= j) {
            std::swap(s[i], s[j]);
            i++; j--;
        }
    }
    
    // Рекурсивная сортировка подмассивов
    quickSort(s.first(j+1));
    if (i < s.size()) quickSort(s.subspan(i));
}

// Менее эффективно при большом количестве итераций
for (size_t i = 0; i < data.size() - 2; ++i) {
    std::span<int> window = data.subspan(i, 3);
    processWindow(window);
}
 
// Более эффективно
for (size_t i = 0; i < data.size() - 2; ++i) {
    // Работаем напрямую с индексами
    processTriple(data[i], data[i+1], data[i+2]);
}

#include <span>
#include <iostream>
#include <thread>
#include <vector>
 
void processChunk(std::span<const int> chunk) {
    // Обработка сегмента данных
    int local_sum = 0;
    for (int value : chunk) {
        local_sum += value;
    }
    std::cout << "Сумма в чанке: " << local_sum << "\n";
}
 
int main() {
    std::vector<int> data(1000);
    // Заполняем данные...
    for (int i = 0; i < 1000; i++) {
        data[i] = i + 1;
    }
    
    std::span<int> fullSpan(data);
    
    // Количество чанков и рабочих потоков
    const size_t num_chunks = 4;
    const size_t chunk_size = fullSpan.size() / num_chunks;
    
    std::vector<std::thread> threads;
    
    // Разделяем данные и запускаем потоки
    for (size_t i = 0; i < num_chunks; ++i) {
        size_t start_idx = i * chunk_size;
        size_t this_chunk_size = (i == num_chunks - 1) 
            ? fullSpan.size() - start_idx  // Последний чанк может быть больше
            : chunk_size;
        
        std::span<int> chunk = fullSpan.subspan(start_idx, this_chunk_size);
        threads.emplace_back(processChunk, chunk);
    }
    
    // Ждем завершения всех потоков
    for (auto& thread : threads) {
        thread.join();
    }
    
    return 0;
}

#include <span>
#include <iostream>
#include <vector>
#include <numeric>
 
// Вычисление скользящего среднего с окном заданного размера
std::vector<double> movingAverage(std::span<const double> data, size_t window_size) {
    if (data.size() < window_size || window_size == 0) {
        return {};
    }
    
    std::vector<double> result(data.size() - window_size + 1);
    
    for (size_t i = 0; i <= data.size() - window_size; ++i) {
        std::span<const double> window = data.subspan(i, window_size);
        double sum = std::accumulate(window.begin(), window.end(), 0.0);
        result[i] = sum / window_size;
    }
    
    return result;
}
 
int main() {
    std::vector<double> temperatures = {
        22.5, 23.1, 24.0, 25.2, 26.5, 26.1, 25.3, 24.8, 23.9
    };
    
    std::span<double> tempSpan(temperatures);
    
    // Вычисляем 3-точечное скользящее среднее
    auto averages = movingAverage(tempSpan, 3);
    
    std::cout << "Температуры: ";
    for (auto temp : tempSpan) {
        std::cout << temp << " ";
    }
    std::cout << "\n";
    
    std::cout << "Скользящие средние: ";
    for (auto avg : averages) {
        std::cout << avg << " ";
    }
    std::cout << "\n";
    
    return 0;
}

#include <span>
#include <iostream>
#include <vector>
#include <algorithm>
 
void analyzeDataSections(std::span<int> data) {
    // Предположим, что первые 20% — заголовок, последние 20% — мета-данные,
    // а середина — содержимое
    size_t header_size = data.size() / 5;
    size_t footer_size = data.size() / 5;
    size_t content_size = data.size() - header_size - footer_size;
    
    std::span<int> header = data.first(header_size);
    std::span<int> content = data.subspan(header_size, content_size);
    std::span<int> footer = data.last(footer_size);
    
    // Обработка заголовка
    int header_sum = std::accumulate(header.begin(), header.end(), 0);
    std::cout << "Сумма заголовка: " << header_sum << "\n";
    
    // Обработка содержимого - например, удвоение всех значений
    for (auto& value : content) {
        value *= 2;  // Изменяет исходные данные!
    }
    
    // Нахождение максимального значения в метаданных
    auto max_elem = std::max_element(footer.begin(), footer.end());
    if (max_elem != footer.end()) {
        std::cout << "Максимальное значение в метаданных: " << *max_elem << "\n";
    }
}
 
int main() {
    std::vector<int> data(50);
    for (int i = 0; i < data.size(); i++) {
        data[i] = i + 1;
    }
    
    std::span<int> dataSpan(data);
    std::cout << "До обработки: " << data[25] << "\n";
    
    analyzeDataSections(dataSpan);
    
    std::cout << "После обработки: " << data[25] << "\n";  // Значение удвоено
    
    return 0;
}

class DataProcessor {
private:
    std::vector<double> raw_data_;
    
public:
    // Конструктор
    DataProcessor(std::span<const double> initial_data) 
        : raw_data_(initial_data.begin(), initial_data.end()) {}
    
    // Предоставляем доступ только к определенным частям данных
    std::span<const double> getFirstQuarter() const {
        return std::span<const double>(raw_data_).first(raw_data_.size() / 4);
    }
    
    std::span<const double> getLastQuarter() const {
        return std::span<const double>(raw_data_).last(raw_data_.size() / 4);
    }
    
    std::span<double> getMiddleSection() {
        size_t quarter = raw_data_.size() / 4;
        return std::span<double>(raw_data_).subspan(quarter, quarter * 2);
    }
    
    // Обработка данных
    void process() {
        auto middle = getMiddleSection();
        for (auto& value : middle) {
            value = std::sqrt(value);  // Изменяем только среднюю часть
        }
    }
};

// Плохо: копирование данных
std::vector<int> processAndReturn(const std::vector<int>& data) {
    std::vector<int> result = data;  // Копирование всех данных
    // Обработка...
    return result;  // Еще одно потенциальное копирование
}
 
// Лучше: используем span для просмотра данных
void processInPlace(std::span<int> data) {
    // Обработка данных на месте
    for (auto& value : data) {
        // Изменяем напрямую
    }
}
 
// Работаем с частями данных без копирования
void processSegments(std::span<int> data) {
    auto first_half = data.first(data.size() / 2);
    auto second_half = data.subspan(data.size() / 2);
    
    processInPlace(first_half);
    
    // Другой тип обработки для второй половины
    for (auto& value : second_half) {
        value += 10;
    }
}

#include <span>
#include <vector>
#include <iostream>
 
// Простая эмуляция двумерного массива
template <typename T>
class Matrix2D {
private:
    std::vector<T> data_;
    size_t rows_, cols_;
 
public:
    Matrix2D(size_t rows, size_t cols) 
        : data_(rows * cols), rows_(rows), cols_(cols) {}
    
    // Получить span, представляющий строку
    std::span<T> getRow(size_t row) {
        if (row >= rows_) throw std::out_of_range("Row index out of range");
        return std::span<T>(data_).subspan(row * cols_, cols_);
    }
    
    // Получить span для всего массива
    std::span<T> data() {
        return std::span<T>(data_);
    }
    
    // Для демонстрации
    void set(size_t row, size_t col, T value) {
        data_[row * cols_ + col] = value;
    }
};
 
int main() {
    Matrix2D<int> matrix(3, 4);
    
    // Заполняем матрицу
    for (size_t i = 0; i < 3; ++i) {
        for (size_t j = 0; j < 4; ++j) {
            matrix.set(i, j, i * 4 + j + 1);
        }
    }
    
    // Получаем вторую строку
    std::span<int> secondRow = matrix.getRow(1);
    
    std::cout << "Вторая строка: ";
    for (int value : secondRow) {
        std::cout << value << " ";
    }
    std::cout << "\n";
    
    // Изменяем значения через span
    for (auto& value : secondRow) {
        value *= 10;
    }
    
    std::cout << "Вторая строка после изменения: ";
    for (int value : matrix.getRow(1)) {
        std::cout << value << " ";
    }
    std::cout << "\n";
    
    return 0;
}

#include <span>
#include <iostream>
#include <numeric>
#include <vector>
#include <algorithm>
 
// Функция для вычисления среднего значения
double calculateAverage(std::span<const int> readings) {
    if (readings.empty()) return 0.0;
    int sum = std::accumulate(readings.begin(), readings.end(), 0);
    return static_cast<double>(sum) / readings.size();
}
 
// Функция для поиска аномалий в исторических данных
void detectAnomalies(std::span<const int> historicalData) {
    int threshold = 30;  // Пример порога для аномальной температуры
    bool foundAnomaly = false;
    
    for (int temp : historicalData) {
        if (temp > threshold) {
            std::cout << "Обнаружена аномалия: " << temp << "\n";
            foundAnomaly = true;
        }
    }
    
    if (!foundAnomaly) {
        std::cout << "Аномалий в исторических данных не обнаружено.\n";
    }
}
 
int main() {
    std::vector<int> temperatures = {25, 26, 28, 27, 29, 31, 33, 32, 30, 35, 34, 36, 37, 33, 28};
    std::span<int> fullData(temperatures);
    
    // Определяем недавние и исторические подпредставления
    std::span<int> recentData = fullData.last(5);        // Последние 5 показаний
    std::span<int> historicalData = fullData.first(10);  // Первые 10 показаний
    
    // Вычисляем и выводим среднюю температуру недавних показаний
    double averageRecent = calculateAverage(recentData);
    std::cout << "Средняя температура недавних данных: " << averageRecent << "\n";
    
    // Ищем аномалии в исторических показаниях
    detectAnomalies(historicalData);
    
    return 0;
}

#include <span>
#include <iostream>
#include <vector>
#include <algorithm>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
 
// Имитация системы мониторинга датчиков
class SensorMonitor {
private:
    std::vector<double> sensor_data_;
    std::mutex data_mutex_;
    std::condition_variable data_cv_;
    bool running_ = true;
    
    // Поток, собирающий данные с датчиков (имитация)
    void dataCollectionThread() {
        while (running_) {
            // Имитация сбора данных с датчика
            {
                std::lock_guard<std::mutex> lock(data_mutex_);
                sensor_data_.push_back(20.0 + rand() % 100 / 10.0);
                // Ограничиваем размер буфера
                if (sensor_data_.size() > 1000) {
                    sensor_data_.erase(sensor_data_.begin(), 
                                     sensor_data_.begin() + sensor_data_.size() - 1000);
                }
            }
            data_cv_.notify_one();
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    }
    
public:
    SensorMonitor() {
        // Запускаем поток сбора данных
        std::thread t(&SensorMonitor::dataCollectionThread, this);
        t.detach();
    }
    
    ~SensorMonitor() {
        running_ = false;
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
    
    // Получение последних N показаний для анализа в реальном времени
    std::vector<double> getRecentReadings(size_t count) {
        std::unique_lock<std::mutex> lock(data_mutex_);
        data_cv_.wait(lock, [this, count]{ return sensor_data_.size() >= count; });
        
        std::vector<double> result;
        std::span<double> recentSpan = std::span(sensor_data_).last(std::min(count, sensor_data_.size()));
        result.assign(recentSpan.begin(), recentSpan.end());
        return result;
    }
    
    // Анализ всех доступных данных с использованием подпредставлений
    void analyzeAllData() {
        std::lock_guard<std::mutex> lock(data_mutex_);
        if (sensor_data_.empty()) return;
        
        std::span<double> allData(sensor_data_);
        
        // Разбиваем данные на три части для разного анализа
        size_t third = allData.size() / 3;
        
        // Разные части данных анализируем по-разному
        std::span<double> firstPart = allData.first(third);
        std::span<double> middlePart = allData.subspan(third, third);
        std::span<double> lastPart = allData.last(allData.size() - 2 * third);
        
        std::cout << "Анализ первой части данных (длинный тренд):\n";
        double avgFirst = std::accumulate(firstPart.begin(), firstPart.end(), 0.0) / firstPart.size();
        std::cout << "  Средняя температура: " << avgFirst << "\n";
        
        std::cout << "Анализ средней части данных (стабильность):\n";
        auto [min, max] = std::minmax_element(middlePart.begin(), middlePart.end());
        std::cout << "  Диапазон температур: " << *min << " - " << *max << "\n";
        std::cout << "  Размах: " << *max - *min << "\n";
        
        std::cout << "Анализ последней части данных (текущий тренд):\n";
        // Анализируем направление тренда
        bool increasing = true;
        for (size_t i = 1; i < lastPart.size(); ++i) {
            if (lastPart[i] < lastPart[i-1]) {
                increasing = false;
                break;
            }
        }
        std::cout << "  Тренд: " << (increasing ? "повышение" : "нестабильный/понижение") << "\n";
    }
};
 
int main() {
    SensorMonitor monitor;
    
    // Имитация различных операций мониторинга
    std::cout << "Запуск системы мониторинга датчиков...\n";
    
    // Ждем накопления некоторых данных
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    // Получаем последние показания
    auto recentData = monitor.getRecentReadings(5);
    std::cout << "Последние 5 показаний: ";
    for (double value : recentData) {
        std::cout << value << " ";
    }
    std::cout << "\n\n";
    
    // Ждем ещё немного для накопления большего количества данных
    std::this_thread::sleep_for(std::chrono::seconds(3));
    
    // Анализируем все накопленные данные
    monitor.analyzeAllData();
    
    return 0;
}

std::span<int> getSpan() {
    std::vector<int> local_data = {1, 2, 3}; // Локальный вектор
    return std::span(local_data);  // ОШИБКА: local_data будет уничтожен
}

std::vector<int> data = {1, 2, 3, 4, 5};
std::span<int> dataSpan(data);
 
data.push_back(6);  // ОШИБКА: может привести к переаллокации вектора
// dataSpan теперь может указывать на недействительную память

std::span<int> fullSpan = /* span из 5 элементов */;
auto invalidSpan = fullSpan.subspan(3, 10);  // ОШИБКА: запрос слишком большой длины

void processData(std::span<int> dataSpan) {
    // Обработка...
    
    // ОШИБКА: span не продлевает время жизни данных
    saveForLater(dataSpan);  // Если исходные данные уничтожены, это приведёт к проблемам
}

// Старый код
void processSensorData(double* data, int size) {
    // Обработка первой части для калибровки (первые 20% данных)
    double calibrationSum = 0.0;
    int calibrationCount = size / 5;
    for (int i = 0; i < calibrationCount; i++) {
        calibrationSum += data[i];
    }
    double calibrationAvg = calibrationSum / calibrationCount;
    
    // Обработка основных данных (средние 60%)
    double* mainData = data + calibrationCount;
    int mainDataSize = size * 3 / 5;
    for (int i = 0; i < mainDataSize; i++) {
        // Применяем калибровку
        mainData[i] -= calibrationAvg;
        
        // Другая обработка...
        if (mainData[i] > 100.0) {
            mainData[i] = 100.0;  // Ограничение значений
        }
    }
    
    // Анализ заключительных данных (последние 20%)
    double* finalData = mainData + mainDataSize;
    int finalDataSize = size - calibrationCount - mainDataSize;
    double finalSum = 0.0;
    for (int i = 0; i < finalDataSize; i++) {
        finalSum += finalData[i];
    }
    
    // И так далее...
}

// Современный код с использованием span
void processSensorData(std::span<double> data) {
    // Разбиваем данные на логические части с помощью span
    size_t calibrationSize = data.size() / 5;
    size_t mainDataSize = data.size() * 3 / 5;
    
    std::span<double> calibrationData = data.first(calibrationSize);
    std::span<double> mainData = data.subspan(calibrationSize, mainDataSize);
    std::span<double> finalData = data.subspan(calibrationSize + mainDataSize);
    
    // Обработка калибровочных данных
    double calibrationAvg = std::accumulate(calibrationData.begin(), 
                                           calibrationData.end(), 0.0) / 
                                           calibrationData.size();
    
    // Обработка основных данных с использованием range-based for
    for (double& value : mainData) {
        // Применяем калибровку
        value -= calibrationAvg;
        
        // Ограничение значений
        value = std::min(value, 100.0);  // Более ясный способ ограничения
    }
    
    // Анализ заключительных данных
    double finalSum = std::accumulate(finalData.begin(), 
                                     finalData.end(), 0.0);
    
    // И так далее...
}

#include <span>
#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>  // Для параллельных алгоритмов из C++17
 
void processDataModern(std::span<double> fullData) {
    // Разделяем данные на три части
    size_t partSize = fullData.size() / 3;
    auto part1 = fullData.first(partSize);
    auto part2 = fullData.subspan(partSize, partSize);
    auto part3 = fullData.last(fullData.size() - 2 * partSize);
    
    // Используем параллельные алгоритмы C++17 для обработки
    std::for_each(std::execution::par_unseq, part1.begin(), part1.end(), 
                 [](double& x) { x = std::log(x + 1.0); });
    
    // Используем структурные привязки (C++17) для работы с результатами
    auto [min_it, max_it] = std::minmax_element(part2.begin(), part2.end());
    double range = *max_it - *min_it;
    
    // Используем алгоритмы трансформации
    std::vector<double> derivatives(part3.size() - 1);
    std::transform(part3.begin(), part3.end() - 1,
                  part3.begin() + 1, derivatives.begin(),
                  [](double x, double y) { return y - x; });
    
    // И так далее...
}