05.1 積型與和型：Tuple、Struct 與 Enum、Either#

-- Haskell：內建 tuple 即無名積型
point :: (Double, Double)
point = (3.0, 4.0)

-- 有名積型 = record / struct
data Point = Point { px :: Double, py :: Double }

# Python：tuple 是無名積、dataclass 是有名積
from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    px: float
    py: float

p = Point(3.0, 4.0)
q = (3.0, 4.0)   # 同一個數學物件 A × B 的兩種寫法

// Rust：tuple 與 struct 都是積型
struct Point { px: f64, py: f64 }
let p = (3.0, 4.0);            // (f64, f64) 積型
let q = Point { px: 3.0, py: 4.0 };

-- Either：二選一和型的標準名字
data Either a b = Left a | Right b

-- 最著名的應用：取代 null
safeDiv :: Int -> Int -> Either String Int
safeDiv _ 0 = Left "除以零"
safeDiv x y = Right (x `div` y)

-- Maybe = 帶「無值」的和型：data Maybe a = Nothing | Just a
-- 這正是 04.1 中 Option 型別的真身！

// Rust：enum 就是有標籤的和型
enum Shape {
    Circle(f64),                    // 一個 f64（半徑）
    Rectangle { w: f64, h: f64 },   // 一個積型
}
// match 是 case 消去規則；漏一個分支 → 編譯錯誤（邏輯強制完備性）
fn area(s: &Shape) -> f64 {
    match s {
        Shape::Circle(r) => std::f64::consts::PI * r * r,
        Shape::Rectangle { w, h } => w * h,
    }
}

# Python 3.10+ 的型別層面終於有了和型：Union / |
from typing import Union

def safe_div(x: int, y: int) -> Union[str, int]:   # str | int
    return "除以零" if y == 0 else x // y

# 但 Python 不強制 case 完備性：和型只有語法，沒有邏輯效力
# 這是「動態型別安全網網眼較大」的又一例證

// 把「連線狀態」用和型精確建模：不合法的狀態在型別上不存在
enum ConnState {
    Disconnected,
    Connecting { attempts: u32 },
    Connected { session_id: u64 },
}
// 「已連線但沒有 session id」這種狀態無法表達——
// 這是「Make illegal states unrepresentable」設計原則

-- 分配律的顯式同構（兩個方向的函數，互為逆）
distrib :: (a, Either b c) -> Either (a, b) (a, c)
distrib (a, Left b)  = Left (a, b)
distrib (a, Right c) = Right (a, c)

undistrib :: Either (a, b) (a, c) -> (a, Either b c)
undistrib (Left (a, b))  = (a, Left b)
undistrib (Right (a, c)) = (a, Right c)
-- distrib . undistrib = id 且 undistrib . distrib = id：這就是「同構」的程式證明

# Result/Option 的本質是和型：錯誤處理 = case 分析
from dataclasses import dataclass
from typing import Generic, TypeVar

T = TypeVar("T"); E = TypeVar("E")

@dataclass
class Ok(Generic[T]):
    value: T

@dataclass
class Err(Generic[E]):
    error: E

Result = Ok[T] | Err[E]   # 型別層面：Result[T, E] = T + E

def parse_int(s: str) -> Result[int, str]:
    try:
        return Ok(int(s))
    except ValueError as e:
        return Err(str(e))

# case 消去：呼叫者被迫處理兩個分支
match parse_int("42"):
    case Ok(v):  print(v * 2)
    case Err(m): print(f"解析失敗: {m}")

def card(t) -> int:
    """計算小型型別的元素個數，驗證 |A+B| = |A|+|B|、|A×B| = |A|·|B|"""
    match t:
        case ("bool",):            return 2
        case ("unit",):            return 1
        case ("void",):            return 0
        case ("sum", a, b):        return card(a) + card(b)
        case ("prod", a, b):       return card(a) * card(b)

Bool = ("bool",); Unit = ("unit",); Void = ("void",)
assert card(("prod", Bool, Bool)) == 4        # 2*2
assert card(("sum",  Bool, Bool)) == 4        # 2+2（可與積區分：值的形狀不同！）
assert card(("sum",  Bool, Void)) == 2        # A + 0 ≅ A
assert card(("prod", Bool, Void)) == 0        # A × 0 ≅ 0
print("所有代數律通過")