Алгебраические типы данных (ADT)Algebraic data types (ADT)

Rust enum — тип-сумма как гражданин первого классаRust enum — a sum type as a first-class citizen

Каждый вариант может нести собственные данные разного типа. Компилятор требует исчерпывающий match — забытый вариант не компилируется, а не падает в рантайме.Each variant can carry its own, differently-typed data. The compiler requires an exhaustive match — a forgotten variant is a compile error, not a runtime crash.

enum Shape {
    Circle { radius: f64 },
    Rectangle { w: f64, h: f64 },
    Triangle { a: f64, b: f64, c: f64 },
}

fn area(s: &Shape) -> f64 {
    match s {
        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
        Shape::Rectangle { w, h } => w * h,
        Shape::Triangle { a, b, c } => { /* формула ГеронаHeron's formula */ 0.0 }
        // пропущенный вариант — ошибка компиляции "non-exhaustive match"// a missing arm is a compile error: "non-exhaustive match"
    }
}

C++ std::variant — сумма поверх системы шаблоновC++ std::variant — a sum type on top of the template system

До C++17 суммы типов в C++ выражались только через union без встроенной проверки тега или через наследование с виртуальной диспетчеризацией. std::variant — типобезопасная тегированная сумма, std::visit — аналог exhaustive match, но исчерпываемость не проверяется компилятором так же строго, как в Rust: об этом заботится сам visitor через if constexpr-цепочки или overload-паттерн.Before C++17, sum types in C++ could only be expressed via a tagless union or via inheritance with dynamic dispatch. std::variant is a type-safe tagged sum, and std::visit is the closest analogue to exhaustive match — though exhaustiveness isn't enforced by the compiler as strictly as in Rust; it's up to the visitor itself, via if constexpr chains or the overload pattern.

using Shape = std::variant<Circle, Rectangle, Triangle>;

double area(const Shape& s) {
    return std::visit([](const auto& shape) { return shape.area(); }, s);
}

TypeScript discriminated union — структурная сумма без enumTypeScript discriminated unions — a structural sum without an enum keyword

TypeScript выражает суммы через объединение интерфейсов с общим литеральным полем-тегом (kind) — компилятор сужает тип внутри каждой ветки switch автоматически по значению тега, и never в default ловит непокрытые варианты статически.TypeScript expresses sums as a union of interfaces sharing a common literal tag field (kind) — the compiler automatically narrows the type inside each switch branch based on the tag's value, and a never in the default case statically catches unhandled variants.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; w: number; h: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.radius ** 2;
    case "rectangle": return s.w * s.h;
    default: const _exhaustive: never = s; return _exhaustive;
  }
}

Python — без нативных ADT, эмуляция через dataclass + UnionPython — no native ADT, emulated via dataclass + Union

Python не имеет тегированных сумм на уровне языка; ближайший идиоматичный аналог — Union из typing над несколькими @dataclass, с проверкой исчерпываемости только статическим анализатором (mypy/pyright), а не рантаймом. С Python 3.10 match с case по типу приближает синтаксис к Rust, но гарантии остаются на совести линтера, а не языка.Python has no tagged sums at the language level; the closest idiomatic analogue is a typing.Union over several @dataclass types, with exhaustiveness checked only by a static analyzer (mypy/pyright), never by the runtime. Since Python 3.10, structural match/case brings the syntax closer to Rust, but the guarantees remain the linter's responsibility, not the language's.