Enum / Sum Type

enum Result<T, E> { Ok(T), Err(E) }

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
}

fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
        Shape::Rectangle { width, height } => width * height,
    } // 全variantを網羅しないとコンパイルエラー
}

enum自体がdiscriminated unionであり、各variantが異なるフィールド構成を持てる。matchは全variantの網羅をコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。が要求し、variant追加時に既存matchの不足を検出できる。melangが目指すモデルに最も近い。

enum Result { Success(User); Failure(String) }

enum Result {
  Success(User)
  Failure(String)
}

fn describe(r : Result) -> String {
  match r {
    Success(user) => "ok: \(user)"
    Failure(message) => "error: \(message)"
  } // 全constructorを網羅しないとコンパイルエラー
}

constructorがpayloadを持てるADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。型としての`enum`を持ち、`match`は全constructorの網羅をコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。が要求する。RustやOCamlに近い設計で、melangが目指すモデルに近い。

enum Result { case success(User); case failure(String) }

enum Result {
    case success(User)
    case failure(String)
}

switch result {
case .success(let user):
    print("ok: \(user)")
case .failure(let message):
    print("error: \(message)")
} // 全caseを網羅しないとコンパイルエラー

`enum`自体がassociated valueを持てるため、variantごとに異なるデータを保持できる。`switch`は全caseの網羅をコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。が要求し、melangが目指す設計に近い候補。

sealed class Result
data class Success(val user: User) : Result()

sealed class Result
data class Success(val user: User) : Result()
data class Failure(val message: String) : Result()

fun describe(r: Result): String = when (r) {
    is Success -> "ok: ${r.user}"
    is Failure -> "error: ${r.message}"
} // whenがsealedを網羅していないとコンパイルエラー

単純な列挙は`enum class`、payload付きのADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。は`sealed class` / `sealed interface`と役割を分ける。`when`式はsealed階層を網羅しないとコンパイルエラーになり、enumのwhenでも同様に網羅性を検査する。

sealed interface Result permits Success, Failure {}

sealed interface Result permits Success, Failure {}
record Success(User user) implements Result {}
record Failure(String message) implements Result {}

String describe(Result r) {
    return switch (r) {
        case Success s -> "ok: " + s.user();
        case Failure f -> "error: " + f.message();
    }; // sealedを網羅しないとコンパイルエラー
}

`enum`はクラスとして状態・メソッドを持てるが、variantごとに異なるフィールド構成を持つADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。ではない。ADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。用途は`sealed interface` + `record`で表現し、switch expressionと組み合わせれば網羅性を検査できる。

enum Result:
  case Success(user: User)
  case Failure(message: String)

enum Result:
  case Success(user: User)
  case Failure(message: String)

def describe(r: Result): String = r match
  case Result.Success(user) => s"ok: $user"
  case Result.Failure(message) => s"error: $message"
// sealedな階層の網羅漏れはコンパイラが検出する

Scala 3の`enum`はvariantごとに異なるフィールドを持てるADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。表現に使え、sealedな階層への`match`は網羅性チェックの対象になる。ただし設定によっては警告どまりになる場合もある。

enum Status { Pending, Running, Completed }

enum Status { Pending, Running, Completed }

switch (status) {
    case Status.Pending: /* ... */ break;
    case Status.Running: /* ... */ break;
} // Completedを書かなくてもコンパイルは通る

`enum`はunderlying integral typeを持つ列挙型で、payloadを持てない。ADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。表現には`record`の継承階層やパターンマッチを組み合わせる必要があり、`switch`の網羅性チェックは基本的にない。

enum class Shape { Circle, Rectangle };

enum class Shape { Circle, Rectangle };

std::variant<double, std::pair<double, double>> payload; // payloadは別途std::variantで表現

`enum` / `enum class`は整数値の列挙にとどまり、variantごとに異なるデータを持てない。payload付きの合算型は`std::variant`やタグ付き構造体を自前で組む必要があり、`switch`の網羅性チェックも基本的にない（コンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。の警告に頼る程度）。

enum Status { PENDING, RUNNING, COMPLETED };

enum Status { PENDING, RUNNING, COMPLETED };

switch (status) {
case PENDING:
    /* ... */
    break;
case RUNNING:
    /* ... */
    break;
} // COMPLETEDを書き忘れてもコンパイルは通る（-Wswitchで警告は出せる）

`enum`はコンパイル時に整数値へ展開されるだけの名前付き定数の集まりで、型としての区別も弱く（実体は`int`と相互変換できる）、variantごとに異なるデータを持たせることもできない。payload付きの合算型を表現したいときは、タグ用の`enum`と`union`を自前で組み合わせた「tagged union」を手で書く必要があり、タグと`union`の対応が壊れていてもコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。は検出しない。この手組みのtagged unionが、C++の`enum`+`std::variant`を経て、Rust・SwiftのenumがVariantとpayloadを安全な形で一体化するまでの出発点になっている。`switch`の網羅性チェックは標準では行われず、`-Wswitch`のようなコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。拡張の警告に頼るしかない。

type Status int
const ( Pending Status = iota; Running; Completed )

type Status int

const (
    Pending Status = iota
    Running
    Completed
)

switch s {
case Pending:
    // ...
case Running:
    // ...
} // Completedの分岐を書き忘れてもコンパイルは通る

言語組み込みのenumがなく、named type + `const` / `iota`で整数定数を列挙する方式を取る。Go公式Wikiも「Go does not support enums」と明記している。`switch`に網羅性チェックはなく、variant追加時の対応漏れをコンパイル時に検出できない。

const Result = union(enum) { success: User, failure: []const u8 };

const Result = union(enum) {
    success: User,
    failure: []const u8,
};

fn describe(r: Result) []const u8 {
    return switch (r) {
        .success => |user| user.name,
        .failure => |message| message,
    }; // 全variantを網羅しないとコンパイルエラー
}

`enum`は整数値ベースの単純な列挙、`union`はvariantごとに異なる型を持てるが現在どのフィールドが有効かを実行時に保持しない生のunion。両者を組み合わせた`union(enum)`が、有効なvariantをタグとして安全に追跡できるtagged unionで、Rustの`enum`と完全に同じ構文ではないが同等のADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。/Sum Typeを表現できる。`switch`は`union(enum)`の全variantを網羅しないとコンパイルエラーになる（`else`を書けば任意の網羅で許容される）。

type result = Success of user | Failure of string

type result =
  | Success of user
  | Failure of string

let describe = function
  | Success user -> "ok: " ^ user
  | Failure message -> "error: " ^ message
(* パターン漏れはコンパイラ警告(non-exhaustive match)になる *)

variant typeが標準機能で、コンストラクタごとに異なるデータを持てる。パターンマッチの網羅漏れはデフォルトで警告になり、`option`型もこの仕組みで表現される。

type Result = Success of User | Failure of string

type Result =
    | Success of User
    | Failure of string

let describe = function
    | Success user -> $"ok: {user}"
    | Failure message -> $"error: {message}"
// パターン漏れはコンパイラ警告(incomplete match)になる

OCaml由来の判別共用体取りうる形が閉じた集合になっている型を、caseごとに異なるデータ（payload）を持たせて表現する仕組み。代数的データ型（ADT）のSum Typeに相当し、F#やOCaml（variant type）で使われる呼び方。パターンマッチと組み合わせて使うことで、全caseの網羅をコンパイラに検証させられる。（Discriminated Union）が標準機能で、caseごとに異なるデータを持てる。パターンマッチの網羅漏れはデフォルトで警告になり、`Option<T>`もこの仕組みで表現される。「不正な状態を表現できなくする」設計をそのまま実現できる型として、書籍『Domain Modeling Made Functional』でも中心的に扱われる。

data Result = Success User | Failure String

data Result = Success User | Failure String

describe :: Result -> String
describe (Success user) = "ok: " ++ show user
describe (Failure message) = "error: " ++ message
-- パターン漏れは -Wincomplete-patterns で警告される

`data`によるADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。が中心で、各コンストラクタが異なるフィールドを持てる。網羅性はコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。の警告（`-Wincomplete-patterns`）として検出でき、警告をエラー扱いにするビルド設定も広く使われる。

{success, User} | {failure, Message}

describe({success, User}) -> "ok: " ++ User;
describe({failure, Message}) -> "error: " ++ Message.
%% 網羅しないケースがあると実行時にfunction_clauseになる

専用のenum型はなく、atomとtagged tuple（`{success, User}`のような組）によるpattern matchingでADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。的に表現する。網羅性はコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。ではなく、実行時のマッチ失敗（`function_clause`エラー）として現れ、プロセスを異常終了させて上位のsupervisorに委ねる「let it crash」の一部として扱われる。Elixirの`{:ok, value}` / `{:error, reason}`という慣習はこの構文をそのまま受け継いでいる。

{:success, user} | {:failure, message}

def describe({:success, user}), do: "ok: #{user}"
def describe({:failure, message}), do: "error: #{message}"
# 網羅しないケースがあると実行時にFunctionClauseErrorになる

専用のenum型はなく、atomとtagged tupleによるpattern matchingでADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。的に表現する。網羅性はコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。ではなく、実行時のマッチ失敗（`FunctionClauseError`）として現れる。

type Result = { kind: 'success'; user: User } | { kind: 'failure'; message: string };

type Result =
  | { kind: 'success'; user: User }
  | { kind: 'failure'; message: string };

function describe(r: Result): string {
  switch (r.kind) {
    case 'success': return `ok: ${r.user}`;
    case 'failure': return `error: ${r.message}`;
    default:
      const exhaustiveCheck: never = r; // 網羅漏れがあると型エラーになる
      return exhaustiveCheck;
  }
}

`enum`はGoに近い整数/文字列定数寄りで、payload付きのADTAlgebraic Data Type（代数的データ型）の略。複数の型を組み合わせて新しい型を作る手法で、「AまたはB」のように取りうる形が閉じた集合になっているものをSum Type（直和型）と呼ぶ。Rustの`enum`やHaskellの`data`が代表例で、各variant（構成要素）が異なるフィールドを持てる点で、単純な整数の列挙とは異なる。表現にはliteral union（discriminated union）を使う。`switch`自体に網羅性チェックはないが、`never`型への代入という慣用句で擬似的に検証できる。

const status = { kind: 'success', user };

const status = { kind: 'success', user };

switch (status.kind) {
  case 'success':
    console.log('ok', status.user);
    break;
  // 'failure'を書き忘れてもエラーにならない
}

組み込みのenumがなく、タグ付きのプレーンオブジェクト等で慣用的に代替する。網羅性を検査する仕組みは言語自体にはない。

enum Status: string { case Pending = 'pending'; case Running = 'running'; }

enum Status: string {
    case Pending = 'pending';
    case Running = 'running';
}

echo match ($status) {
    Status::Pending => 'pending',
    Status::Running => 'running',
}; // 網羅しないと実行時にUnhandledMatchErrorになる

backed enumで文字列/整数値を持てるが、variantごとに異なるフィールドは持てない。`match`式は全caseを網羅しないと、コンパイル時ではなく実行時に`UnhandledMatchError`になる。

STATUSES = %i[pending running completed]

status = :pending

case status
when :pending
  # ...
when :running
  # ...
end # :completedを書き忘れても実行は通る

組み込みのenumがなく、symbolや定数で列挙値を代替するのが慣用。網羅性を検査する仕組みはなく、書き忘れは実行時にしか気づけない。

class Status(Enum):
    PENDING = "pending"

from enum import Enum

class Status(Enum):
    PENDING = "pending"
    RUNNING = "running"

match status:
    case Status.PENDING:
        ...
    case Status.RUNNING:
        ...
    # 網羅チェックはmypy等の型チェッカに頼る必要がある

標準ライブラリの`enum.Enum`はpayloadを持たず、`match`文自体に網羅性チェックは基本的にない。型チェッカ（`mypy`等）で`assert_never`などを使えば擬似的に検証できる。