Примеры на C (концептуально)
1. Maybe-монада (обработка ошибок без исключений)
c// Тип Maybe
typedef struct {
    bool has_value;
    int value;
} Maybe;

Maybe nothing() { return (Maybe){false, 0}; }
Maybe just(int v) { return (Maybe){true, v}; }

// bind для Maybe
Maybe bind(Maybe m, Maybe (*f)(int)) {
    if (!m.has_value) return nothing();
    return f(m.value);
}

// --- БЕЗ do-нотации ---
Maybe safe_div(int a, int b) {
    return b == 0 ? nothing() : just(a / b);
}

// Вычислить (100 / x) / y  — без DSL это вложенные лямбды/функции
Maybe compute(int x, int y) {
    // В C нет лямбд, поэтому bind превращается в ад указателей на функции
    Maybe mx = safe_div(100, x);
    if (!mx.has_value) return nothing();
    Maybe my = safe_div(mx.value, y);
    if (!my.has_value) return nothing();
    return my;
}

// --- С do-нотацией (псевдокод того, что делает DSL) ---
// DO(
//   LET a IS(safe_div(100, x));
//   LET b IS(safe_div(a, y));
//   return just(b);
// )
// Макрос разворачивает это в правильные проверки автоматически
2. Реальный аналог в C — через goto (классический паттерн)
c// Это фактически ручная do-нотация, которую пишут в C годами:
int process(const char *path) {
    FILE *f = NULL;
    char *buf = NULL;
    int result = -1;

    f = fopen(path, "r");
    if (!f) goto cleanup;          // bind: если нет значения — выход

    buf = malloc(1024);
    if (!buf) goto cleanup;        // bind: следующий шаг

    if (fread(buf, 1, 1024, f) < 0) goto cleanup;

    result = process_buffer(buf);  // return: финальное значение

cleanup:
    free(buf);
    if (f) fclose(f);
    return result;
}
Это буквально то же самое что do-нотация для Maybe/Either — при первой ошибке "выпадаем" из цепочки.
3. Современный C — через макросы (ближе к новости)
c// Упрощённая версия того, что делает описанный DSL:
#define TRY(expr)        \
    ({                   \
        auto _v = (expr);\
        if (!_v.ok) return _v; \
        _v.value;        \
    })

// Result-тип
typedef struct { bool ok; int value; } Result;

Result safe_sqrt(int x) {
    if (x < 0) return (Result){false, 0};
    return (Result){true, (int)sqrt(x)};
}

// С макросом:
Result compute(int a, int b) {
    int x = TRY(safe_sqrt(a));   // если ошибка — функция сразу вернёт ошибку
    int y = TRY(safe_sqrt(b));
    return (Result){true, x + y};
}

Что именно делает описанный DSL
cpp// Это:
auto result = DO(
    LET x IS(mx);
    LET y IS(my);
    return make_value(x, y);
);

// Разворачивается препроцессором в:
auto result = bind(mx, [&](auto x) {
    return bind(my, [&](auto y) {
        return make_value(x, y);
    });
});
Каждый LET a IS(m) становится bind(m, [&](auto a) { ... }), где ... — всё что идёт после. Это вложенные замыкания, сгенерированные макросом.

Почему это интересно
Сложность в том, что макросы C — однопроходные и не имеют состояния, поэтому построить такую "вложенную" структуру из плоского списка LET нетривиально. Описанная техника решает именно эту задачу — трансформацию плоской последовательности в дерево вызовов через препроцессор.
По сути, это то, что Rust решил встроенным ?, а Haskell — do. Только сделано на макросах C/C++.

А внутри все равно обычная императивщина - так проц работает, не умеет он в эти твои монады-шмонады. А подобные финты давно в сишке в препроцессоре используются, ты просто йододефицитный и не знаешь об этом.

Вангую что аналог оператора >>=

Когда Связываешь две сущности через Цепочку действий, которые надо выполнить. В функциональных языках состояние переменной недопустимо (недостижимо), но оно необходимо существует. Есть только опосредованный доступ через функцию.

Что за дибилизм выражать свои желания в инфинитиве? Ещё хуже, чем в третьем лице.

Perl — неявные монады через контекст и $_
Shell pipelines — | это буквально bind для потоков
jQuery — .then().filter().map() — монада над DOM
Promise/async-await — монада над асинхронностью, do-нотация в disguise
Rust ? — монада Either/Result, синтаксический сахар над bind
C макросы — вот это

И каждый раз разработчики говорят "мы не хотим теорию категорий, мы просто хотим удобный синтаксис" — и приходят ровно к тому же месту.
Хаскелисты на это смотрят с тихой улыбкой уже лет 30. 🙂

Потому что гладиолус или где?
У раста, если че, нет препроцессора.

Вообще, ооп как парадигме нужно дать отдохнуть лет 10.

В современном объектно-ориентированном дотнете, к примеру, уже давно не пишут в стиле "фабрика стратегий абстрактных провайдеров посетителей".