構造的型付け（TypeScript のデフォルト）:
 
  type UserId = string;
  type OrderId = string;
 
  UserId と OrderId は同じ構造（string）
       ↓
  相互に代入可能!
 
  function getUser(id: UserId): User { ... }
  const orderId: OrderId = "order-123";
  getUser(orderId);  // エラーにならない!
 
公称型（ブランド型で擬似的に実現）:
 
  type UserId = string & { __brand: "UserId" };
  type OrderId = string & { __brand: "OrderId" };
 
  UserId と OrderId は構造が異なる
       ↓
  相互に代入不可!
 
  getUser(orderId);  // コンパイルエラー!

// 構造的型付けの問題
type UserId = string;
type OrderId = string;
type ProductId = string;
 
function getUser(id: UserId): void {
  console.log(`Fetching user with ID: ${id}`);
}
 
function getOrder(id: OrderId): void {
  console.log(`Fetching order with ID: ${id}`);
}
 
const userId: UserId = "user-1";
const orderId: OrderId = "order-1";
 
// 全てコンパイルが通ってしまう
getUser(orderId);    // バグ! OrderId を渡している
getOrder(userId);    // バグ! UserId を渡している
 
// 実行時に初めて問題が発覚
// => "Fetching user with ID: order-1"  ← 間違った ID で検索

type PatientId = string;
type AppointmentId = string;
 
function cancelAppointment(appointmentId: AppointmentId): void {
  // 予約をキャンセル
}
 
function deletePatient(patientId: PatientId): void {
  // 患者記録を削除（危険な操作）
}
 
const appointment: AppointmentId = "apt-789";
const patient: PatientId = "patient-456";
 
// 型チェックが通ってしまい、患者記録を誤って削除
deletePatient(appointment); // コンパイルエラーにならない!

type JPY = number;
type USD = number;
 
function transferJPY(amount: JPY): void {
  console.log(`Transferring ¥${amount}`);
}
 
const usdAmount: USD = 100; // $100
transferJPY(usdAmount); // ¥100 として処理されてしまう（為替レート無視）

type Meters = number;
type Feet = number;
 
function calculateTrajectory(altitude: Meters): void {
  // メートル単位で計算
}
 
const altitudeInFeet: Feet = 3000;
calculateTrajectory(altitudeInFeet); // フィート値をメートルとして処理

// ブランド型の定義
type Brand<T, BrandName extends string> = T & { readonly __brand: BrandName };
 
type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;
 
function getUser(id: UserId): void {
  console.log(`Fetching user: ${id}`);
}
 
function getOrder(id: OrderId): void {
  console.log(`Fetching order: ${id}`);
}
 
// コンストラクタ関数でブランドを付与
const userId = (id: string): UserId => id as UserId;
const orderId = (id: string): OrderId => id as OrderId;
 
const uid = userId("user-123");
const oid = orderId("order-456");
 
getUser(uid);  // ✓ OK
getUser(oid);  // ✗ コンパイルエラー!
// Error: Argument of type 'OrderId' is not assignable to parameter of type 'UserId'.
//   Type 'OrderId' is not assignable to type '{ readonly __brand: "UserId"; }'.

graph TB
    subgraph "構造的型付け（TypeScript デフォルト）"
        A1[type UserId = string]
        A2[type OrderId = string]
        A3[同じ構造]
        A4[相互に代入可能]
        A1 --> A3
        A2 --> A3
        A3 --> A4
    end
 
    subgraph "公称型付け（ブランド型で実現）"
        B1["type UserId = string & { __brand: 'UserId' }"]
        B2["type OrderId = string & { __brand: 'OrderId' }"]
        B3[異なる構造]
        B4[代入不可]
        B1 --> B3
        B2 --> B3
        B3 --> B4
    end

// ジェネリック型の定義
type Brand<T, BrandName extends string> = T & { readonly __brand: BrandName };
 
// ブランド型の定義
type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;
type ProductId = Brand<string, "ProductId">;
 
// コンストラクタ関数
function userId(id: string): UserId {
  return id as UserId;
}
 
function orderId(id: string): OrderId {
  return id as OrderId;
}
 
function productId(id: string): ProductId {
  return id as ProductId;
}

function getUser(id: UserId): void {
  console.log(`Fetching user: ${id}`);
}
 
function getOrder(id: OrderId): void {
  console.log(`Fetching order: ${id}`);
}
 
const uid = userId("user-123");
const oid = orderId("order-456");
 
getUser(uid);  // ✓ OK
getUser(oid);  // ✗ コンパイルエラー!
// Error: Type 'OrderId' is not assignable to type 'UserId'.
//   Type 'OrderId' is not assignable to type '{ __brand: "UserId" }'.

// 別ファイルで同じブランド名を使うと互換性が生まれる
type UserIdV1 = Brand<string, "UserId">;
type UserIdV2 = Brand<string, "UserId">;
 
const v1: UserIdV1 = "user-1" as UserIdV1;
const v2: UserIdV2 = v1; // OK（意図しない互換性）

// unique symbol で完全にユニークなブランドを作成
declare const UserIdBrand: unique symbol;
declare const OrderIdBrand: unique symbol;
declare const ProductIdBrand: unique symbol;
 
type UserId = string & { readonly [UserIdBrand]: typeof UserIdBrand };
type OrderId = string & { readonly [OrderIdBrand]: typeof OrderIdBrand };
type ProductId = string & { readonly [ProductIdBrand]: typeof ProductIdBrand };
 
// コンストラクタ関数
function userId(id: string): UserId {
  return id as UserId;
}
 
function orderId(id: string): OrderId {
  return id as OrderId;
}
 
function productId(id: string): ProductId {
  return id as ProductId;
}

const uid = userId("user-123");
const oid = orderId("order-456");
 
function getUser(id: UserId): void {
  console.log(`User: ${id}`);
}
 
getUser(uid); // ✓ OK
getUser(oid); // ✗ コンパイルエラー!

// 別ファイルで同じ名前でも、unique symbol は異なる型
// file1.ts
declare const UserIdBrand: unique symbol;
type UserId = string & { readonly [UserIdBrand]: typeof UserIdBrand };
 
// file2.ts
declare const UserIdBrand: unique symbol; // 同じ名前でも別の型
type UserId = string & { readonly [UserIdBrand]: typeof UserIdBrand };
 
// file1 の UserId と file2 の UserId は互換性がない!

// プレフィックスでブランドを識別
type UserId = `user_${string}`;
type OrderId = `order_${string}`;
type ProductId = `product_${string}`;
 
// コンストラクタ（バリデーション付き）
function userId(id: string): UserId {
  if (!id.startsWith("user_")) {
    throw new Error("Invalid UserId format");
  }
  return id as UserId;
}
 
function orderId(id: string): OrderId {
  if (!id.startsWith("order_")) {
    throw new Error("Invalid OrderId format");
  }
  return id as OrderId;
}

const uid: UserId = "user_123"; // ✓ OK（リテラルが一致）
const oid: OrderId = "order_456"; // ✓ OK
 
// const bad: UserId = "123"; // ✗ エラー（パターンが一致しない）
 
function getUser(id: UserId): void {
  console.log(`User: ${id}`);
}
 
getUser(uid); // ✓ OK
getUser(oid); // ✗ エラー

// ジェネリック Brand 型
type Brand<T, BrandName extends string> = T & { readonly __brand: BrandName };
 
// 特定のブランドに unique symbol を使う
declare const EmailBrand: unique symbol;
type Email = string & { readonly [EmailBrand]: typeof EmailBrand };
 
// 一般的な ID は __brand パターン
type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;
 
// Email だけ特別に厳密にしたい場合
function email(value: string): Email {
  if (!value.includes("@")) {
    throw new Error("Invalid email");
  }
  return value as Email;
}

スマートコンストラクタのフロー:
 
  string (未検証)
     |
     v
  +------------------+
  | validate & brand |
  +------------------+
     |           |
     v           v
  Ok(Email)   Err("invalid")
  (検証済み)   (拒否)
     |
     v
  sendEmail(email: Email)
  → 型が保証するので再検証不要

// Result 型の定義
type Result<T, E> =
  | { ok: true; value: T }
  | { ok: false; error: E };
 
function Ok<T>(value: T): Result<T, never> {
  return { ok: true, value };
}
 
function Err<E>(error: E): Result<never, E> {
  return { ok: false, error };
}
 
function isOk<T, E>(result: Result<T, E>): result is { ok: true; value: T } {
  return result.ok;
}
 
function isErr<T, E>(result: Result<T, E>): result is { ok: false; error: E } {
  return !result.ok;
}

type Brand<T, BrandName extends string> = T & { readonly __brand: BrandName };
 
// ブランド型の定義
type Email = Brand<string, "Email">;
type NonEmptyString = Brand<string, "NonEmptyString">;
type PositiveNumber = Brand<number, "PositiveNumber">;
type Percentage = Brand<number, "Percentage">; // 0-100
type UUID = Brand<string, "UUID">;
type URL = Brand<string, "URL">;
 
// スマートコンストラクタ
function email(value: string): Result<Email, string> {
  const trimmed = value.trim();
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 
  if (!emailRegex.test(trimmed)) {
    return Err(`Invalid email format: ${value}`);
  }
 
  return Ok(trimmed as Email);
}
 
function nonEmpty(value: string): Result<NonEmptyString, string> {
  const trimmed = value.trim();
 
  if (trimmed.length === 0) {
    return Err("String must not be empty");
  }
 
  return Ok(trimmed as NonEmptyString);
}
 
function positiveNumber(value: number): Result<PositiveNumber, string> {
  if (!Number.isFinite(value)) {
    return Err("Must be a finite number");
  }
 
  if (value <= 0) {
    return Err(`Must be positive, got: ${value}`);
  }
 
  return Ok(value as PositiveNumber);
}
 
function percentage(value: number): Result<Percentage, string> {
  if (!Number.isFinite(value)) {
    return Err("Must be a finite number");
  }
 
  if (value < 0 || value > 100) {
    return Err(`Must be between 0 and 100, got: ${value}`);
  }
 
  return Ok(value as Percentage);
}
 
function uuid(value: string): Result<UUID, string> {
  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
  if (!uuidRegex.test(value)) {
    return Err(`Invalid UUID format: ${value}`);
  }
 
  return Ok(value as UUID);
}
 
function url(value: string): Result<URL, string> {
  try {
    new globalThis.URL(value); // URL コンストラクタで検証
    return Ok(value as URL);
  } catch {
    return Err(`Invalid URL: ${value}`);
  }
}

interface UserRegistration {
  email: Email;
  name: NonEmptyString;
  age: PositiveNumber;
  website: URL;
}
 
function registerUser(
  emailInput: string,
  nameInput: string,
  ageInput: number,
  websiteInput: string
): Result<UserRegistration, string[]> {
  const errors: string[] = [];
 
  const emailResult = email(emailInput);
  const nameResult = nonEmpty(nameInput);
  const ageResult = positiveNumber(ageInput);
  const websiteResult = url(websiteInput);
 
  if (isErr(emailResult)) errors.push(emailResult.error);
  if (isErr(nameResult)) errors.push(nameResult.error);
  if (isErr(ageResult)) errors.push(ageResult.error);
  if (isErr(websiteResult)) errors.push(websiteResult.error);
 
  if (errors.length > 0) {
    return Err(errors);
  }
 
  // ここに到達した時点で、全ての値が検証済み
  return Ok({
    email: emailResult.value,
    name: nameResult.value,
    age: ageResult.value,
    website: websiteResult.value,
  });
}
 
// 使用例
const result = registerUser(
  "alice@example.com",
  "Alice",
  30,
  "https://alice.dev"
);
 
if (isOk(result)) {
  console.log("User registered:", result.value);
  // result.value.email は Email 型（再検証不要）
  sendWelcomeEmail(result.value.email);
} else {
  console.error("Validation errors:", result.error);
}
 
function sendWelcomeEmail(to: Email): void {
  // to は Email 型なので、有効なメールアドレスであることが保証されている
  console.log(`Sending email to ${to}`);
}

// 複雑なバリデーション: パスワード
type Password = Brand<string, "Password">;
 
function password(value: string): Result<Password, string[]> {
  const errors: string[] = [];
 
  if (value.length < 8) {
    errors.push("Password must be at least 8 characters");
  }
 
  if (!/[A-Z]/.test(value)) {
    errors.push("Password must contain at least one uppercase letter");
  }
 
  if (!/[a-z]/.test(value)) {
    errors.push("Password must contain at least one lowercase letter");
  }
 
  if (!/[0-9]/.test(value)) {
    errors.push("Password must contain at least one digit");
  }
 
  if (!/[!@#$%^&*]/.test(value)) {
    errors.push("Password must contain at least one special character");
  }
 
  if (errors.length > 0) {
    return Err(errors);
  }
 
  return Ok(value as Password);
}
 
// 使用例
const pw1 = password("weak");
console.log(pw1);
// { ok: false, error: [ "Password must be at least 8 characters", ... ] }
 
const pw2 = password("Strong123!");
console.log(pw2);
// { ok: true, value: "Strong123!" as Password }

// ID 系のブランド型
type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;
type ProductId = Brand<string, "ProductId">;
type CartId = Brand<string, "CartId">;
type PaymentId = Brand<string, "PaymentId">;
 
// 金額系のブランド型
type JPY = Brand<number, "JPY">;
type USD = Brand<number, "USD">;
type Points = Brand<number, "Points">;
 
// 数量系のブランド型
type Quantity = Brand<number, "Quantity">;
type Stock = Brand<number, "Stock">;
 
// ドメインモデル
interface User {
  id: UserId;
  email: Email;
  name: NonEmptyString;
  points: Points;
}
 
interface Product {
  id: ProductId;
  name: NonEmptyString;
  priceJPY: JPY;
  priceUSD: USD;
  stock: Stock;
}
 
interface OrderItem {
  productId: ProductId;
  quantity: Quantity;
  priceJPY: JPY;
}
 
interface Order {
  id: OrderId;
  userId: UserId;
  items: OrderItem[];
  totalJPY: JPY;
  paymentId: PaymentId;
}

// 在庫チェック
function hasEnoughStock(stock: Stock, quantity: Quantity): boolean {
  return (stock as number) >= (quantity as number);
}
 
// 小計計算
function calculateSubtotal(price: JPY, quantity: Quantity): JPY {
  return ((price as number) * (quantity as number)) as JPY;
}
 
// 合計計算
function calculateTotal(items: OrderItem[]): JPY {
  const total = items.reduce((sum, item) => {
    return sum + calculateSubtotal(item.priceJPY, item.quantity);
  }, 0);
  return total as JPY;
}
 
// 注文作成
function createOrder(
  orderId: OrderId,
  userId: UserId,
  items: OrderItem[],
  paymentId: PaymentId
): Result<Order, string> {
  if (items.length === 0) {
    return Err("Order must contain at least one item");
  }
 
  const totalJPY = calculateTotal(items);
 
  return Ok({
    id: orderId,
    userId,
    items,
    totalJPY,
    paymentId,
  });
}

// リポジトリインターフェース
interface UserRepository {
  findById(id: UserId): Promise<User | null>;
  save(user: User): Promise<void>;
}
 
interface ProductRepository {
  findById(id: ProductId): Promise<Product | null>;
  updateStock(id: ProductId, stock: Stock): Promise<void>;
}
 
interface OrderRepository {
  findById(id: OrderId): Promise<Order | null>;
  findByUserId(userId: UserId): Promise<Order[]>;
  save(order: Order): Promise<void>;
}
 
// 実装例（メモリストレージ）
class InMemoryUserRepository implements UserRepository {
  private users = new Map<UserId, User>();
 
  async findById(id: UserId): Promise<User | null> {
    return this.users.get(id) ?? null;
  }
 
  async save(user: User): Promise<void> {
    this.users.set(user.id, user);
  }
}
 
// ブランド型により、間違った ID を渡すとコンパイルエラー
const userRepo = new InMemoryUserRepository();
const productRepo = new InMemoryProductRepository();
 
const uid: UserId = "user-1" as UserId;
const pid: ProductId = "product-1" as ProductId;
 
await userRepo.findById(uid); // ✓ OK
// await userRepo.findById(pid); // ✗ エラー! ProductId を UserId に渡せない

graph TD
    subgraph "ID ブランド型"
        UserId
        OrderId
        ProductId
        CartId
        PaymentId
    end
 
    subgraph "金額ブランド型"
        JPY
        USD
        Points
    end
 
    subgraph "数量ブランド型"
        Quantity
        Stock
    end
 
    User -->|has| UserId
    User -->|has| Points
    Order -->|has| OrderId
    Order -->|belongs to| UserId
    Order -->|has| PaymentId
    Order -->|total| JPY
    Product -->|has| ProductId
    Product -->|price| JPY
    Product -->|price| USD
    Product -->|has| Stock
    OrderItem -->|quantity| Quantity
    OrderItem -->|refers to| ProductId

// ユースケース: 商品をカートに追加
async function addToCart(
  userId: UserId,
  productId: ProductId,
  quantity: Quantity,
  userRepo: UserRepository,
  productRepo: ProductRepository
): Promise<Result<void, string>> {
  // ユーザーの取得
  const user = await userRepo.findById(userId);
  if (!user) {
    return Err(`User not found: ${userId}`);
  }
 
  // 商品の取得
  const product = await productRepo.findById(productId);
  if (!product) {
    return Err(`Product not found: ${productId}`);
  }
 
  // 在庫チェック
  if (!hasEnoughStock(product.stock, quantity)) {
    return Err(`Insufficient stock for product: ${productId}`);
  }
 
  // カートに追加（省略）
 
  return Ok(undefined);
}
 
// 呼び出し側
const uid = "user-123" as UserId;
const pid = "product-456" as ProductId;
const qty = 2 as Quantity;
 
const result = await addToCart(uid, pid, qty, userRepo, productRepo);
 
if (isErr(result)) {
  console.error(result.error);
}

import { z } from "zod";
 
// Zod スキーマでブランド型を生成
const UserIdSchema = z.string().uuid().brand<"UserId">();
type UserId = z.infer<typeof UserIdSchema>;
// 型: string & { __brand: "UserId" }
 
const EmailSchema = z.string().email().brand<"Email">();
type Email = z.infer<typeof EmailSchema>;
 
const PositiveSchema = z.number().positive().brand<"Positive">();
type Positive = z.infer<typeof PositiveSchema>;
 
const PercentageSchema = z.number().min(0).max(100).brand<"Percentage">();
type Percentage = z.infer<typeof PercentageSchema>;

// パース成功時にブランドが付与される
const userId = UserIdSchema.parse("550e8400-e29b-41d4-a716-446655440000");
// userId: UserId
 
const email = EmailSchema.parse("alice@example.com");
// email: Email
 
// パース失敗時は例外
try {
  const invalid = EmailSchema.parse("not-an-email");
} catch (error) {
  if (error instanceof z.ZodError) {
    console.error(error.errors);
    // [{ message: "Invalid email", ... }]
  }
}
 
// safeParse で例外なしバリデーション
const result = EmailSchema.safeParse("test@example.com");
if (result.success) {
  console.log(result.data); // Email 型
} else {
  console.error(result.error.errors);
}

// ユーザー登録スキーマ
const UserRegistrationSchema = z.object({
  email: EmailSchema,
  password: z.string()
    .min(8, "Password must be at least 8 characters")
    .regex(/[A-Z]/, "Must contain uppercase letter")
    .regex(/[a-z]/, "Must contain lowercase letter")
    .regex(/[0-9]/, "Must contain digit")
    .brand<"Password">(),
  name: z.string()
    .min(1, "Name must not be empty")
    .brand<"NonEmptyString">(),
  age: z.number()
    .int()
    .positive()
    .brand<"Age">(),
});
 
type UserRegistration = z.infer<typeof UserRegistrationSchema>;
// {
//   email: Email,
//   password: Password,
//   name: NonEmptyString,
//   age: Age
// }
 
// 使用例
const input = {
  email: "alice@example.com",
  password: "StrongPass123",
  name: "Alice",
  age: 30,
};
 
const result = UserRegistrationSchema.safeParse(input);
if (result.success) {
  const registration: UserRegistration = result.data;
  await createUser(registration);
} else {
  console.error(result.error.flatten());
}

// カスタム検証ロジック付きブランド型
const SlugSchema = z.string()
  .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Invalid slug format")
  .brand<"Slug">();
 
type Slug = z.infer<typeof SlugSchema>;
 
const PhoneNumberSchema = z.string()
  .regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number")
  .brand<"PhoneNumber">();
 
type PhoneNumber = z.infer<typeof PhoneNumberSchema>;
 
// 使用例
const slug = SlugSchema.parse("my-blog-post"); // ✓ OK
const phone = PhoneNumberSchema.parse("+819012345678"); // ✓ OK
 
// SlugSchema.parse("My Blog Post"); // ✗ エラー（大文字とスペース）

// 手動定義のブランド型
type Brand<T, B extends string> = T & { readonly __brand: B };
type ManualUserId = Brand<string, "UserId">;
 
// Zod 定義のブランド型
const ZodUserIdSchema = z.string().uuid().brand<"UserId">();
type ZodUserId = z.infer<typeof ZodUserIdSchema>;
 
// 互換性チェック
const manualId: ManualUserId = "uuid-here" as ManualUserId;
const zodId: ZodUserId = ZodUserIdSchema.parse("550e8400-e29b-41d4-a716-446655440000");
 
// 互換性がある（同じブランド名）
const compatible: ManualUserId = zodId; // ✓ OK
const alsoCompatible: ZodUserId = manualId; // ✓ OK
 
// ただし、Zod のパースを経由しないとランタイム検証がない
function processUser(id: ManualUserId): void {
  // id が本当に有効な UUID かは保証されない
}
 
function processUserSafe(id: ZodUserId): void {
  // id は Zod の検証を通っているので UUID が保証されている
}

// 入力を正規化してからブランドを付与
const NormalizedEmailSchema = z.string()
  .transform(val => val.toLowerCase().trim())
  .pipe(z.string().email().brand<"Email">());
 
type NormalizedEmail = z.infer<typeof NormalizedEmailSchema>;
 
const email1 = NormalizedEmailSchema.parse("  Alice@EXAMPLE.com  ");
console.log(email1); // "alice@example.com" (NormalizedEmail 型)
 
// 日付文字列を Date オブジェクトに変換してブランド付与
const TimestampSchema = z.string()
  .datetime()
  .transform(val => new Date(val))
  .brand<"Timestamp">();
 
type Timestamp = z.infer<typeof TimestampSchema>;
// Date & { __brand: "Timestamp" }

// 長さの単位
type Meters = Brand<number, "Meters">;
type Kilometers = Brand<number, "Kilometers">;
type Miles = Brand<number, "Miles">;
type Feet = Brand<number, "Feet">;
 
// 時間の単位
type Seconds = Brand<number, "Seconds">;
type Minutes = Brand<number, "Minutes">;
type Hours = Brand<number, "Hours">;
 
// 速度の単位
type MetersPerSecond = Brand<number, "MetersPerSecond">;
type KilometersPerHour = Brand<number, "KilometersPerHour">;
type MilesPerHour = Brand<number, "MilesPerHour">;
 
// 質量の単位
type Kilograms = Brand<number, "Kilograms">;
type Grams = Brand<number, "Grams">;
type Pounds = Brand<number, "Pounds">;
 
// コンストラクタ
const meters = (v: number): Meters => v as Meters;
const kilometers = (v: number): Kilometers => v as Kilometers;
const miles = (v: number): Miles => v as Miles;
const seconds = (v: number): Seconds => v as Seconds;
const kilograms = (v: number): Kilograms => v as Kilograms;

// 長さの変換
function kmToMeters(km: Kilometers): Meters {
  return ((km as number) * 1000) as Meters;
}
 
function metersToKm(m: Meters): Kilometers {
  return ((m as number) / 1000) as Kilometers;
}
 
function milesToKm(mi: Miles): Kilometers {
  return ((mi as number) * 1.60934) as Kilometers;
}
 
function feetToMeters(ft: Feet): Meters {
  return ((ft as number) * 0.3048) as Meters;
}
 
// 時間の変換
function minutesToSeconds(min: Minutes): Seconds {
  return ((min as number) * 60) as Seconds;
}
 
function hoursToSeconds(hr: Hours): Seconds {
  return ((hr as number) * 3600) as Seconds;
}
 
// 質量の変換
function gramsToKilograms(g: Grams): Kilograms {
  return ((g as number) / 1000) as Kilograms;
}
 
function poundsToKilograms(lb: Pounds): Kilograms {
  return ((lb as number) * 0.453592) as Kilograms;
}

// 速度 = 距離 / 時間
function calculateSpeed(distance: Meters, time: Seconds): MetersPerSecond {
  return ((distance as number) / (time as number)) as MetersPerSecond;
}
 
// 距離 = 速度 × 時間
function calculateDistance(speed: MetersPerSecond, time: Seconds): Meters {
  return ((speed as number) * (time as number)) as Meters;
}
 
// 運動エネルギー = 0.5 × 質量 × 速度^2
type Joules = Brand<number, "Joules">;
 
function kineticEnergy(mass: Kilograms, speed: MetersPerSecond): Joules {
  const m = mass as number;
  const v = speed as number;
  return (0.5 * m * v * v) as Joules;
}
 
// 使用例
const distance = meters(100);
const time = seconds(10);
const speed = calculateSpeed(distance, time);
console.log(`Speed: ${speed} m/s`); // Speed: 10 m/s
 
const mass = kilograms(50);
const energy = kineticEnergy(mass, speed);
console.log(`Energy: ${energy} J`); // Energy: 2500 J
 
// コンパイルエラー例
const km = kilometers(5);
// calculateSpeed(km, time); // ✗ エラー! Kilometers は Meters ではない
 
// 正しい使い方: 変換してから渡す
const speedFromKm = calculateSpeed(kmToMeters(km), time);

type JPY = Brand<number, "JPY">;
type USD = Brand<number, "USD">;
type EUR = Brand<number, "EUR">;
type Points = Brand<number, "Points">;
 
// 同一通貨同士の加算
function addMoney<T extends Brand<number, string>>(a: T, b: T): T {
  return ((a as number) + (b as number)) as T;
}
 
// 同一通貨同士の減算
function subtractMoney<T extends Brand<number, string>>(a: T, b: T): T {
  return ((a as number) - (b as number)) as T;
}
 
// スカラー倍
function multiplyMoney<T extends Brand<number, string>>(
  amount: T,
  factor: number
): T {
  return ((amount as number) * factor) as T;
}
 
// 割り算（割合を求める）
function divideMoney<T extends Brand<number, string>>(
  dividend: T,
  divisor: T
): number {
  return (dividend as number) / (divisor as number);
}
 
// 為替レート型
type ExchangeRate<From extends string, To extends string> = Brand<
  number,
  `ExchangeRate_${From}_${To}`
>;
 
type USD_to_JPY = ExchangeRate<"USD", "JPY">;
type JPY_to_USD = ExchangeRate<"JPY", "USD">;
 
// 通貨変換
function convertCurrency(
  amount: USD,
  rate: USD_to_JPY
): JPY {
  return ((amount as number) * (rate as number)) as JPY;
}
 
// 使用例
const priceJPY1 = 1000 as JPY;
const priceJPY2 = 2000 as JPY;
const totalJPY = addMoney(priceJPY1, priceJPY2); // 3000 JPY
 
const priceUSD = 10 as USD;
// addMoney(priceJPY1, priceUSD); // ✗ エラー! JPY と USD は加算不可
 
// 為替変換
const rate: USD_to_JPY = 150 as USD_to_JPY; // 1 USD = 150 JPY
const converted = convertCurrency(priceUSD, rate); // 1500 JPY
 
// 消費税計算
function addTax(priceJPY: JPY, taxRate: Percentage): JPY {
  return multiplyMoney(priceJPY, 1 + (taxRate as number) / 100);
}
 
const taxRate = 10 as Percentage; // 10%
const priceWithTax = addTax(priceJPY1, taxRate); // 1100 JPY

graph LR
    subgraph "同一単位の演算"
        A[Meters] -->|+| B[Meters]
        B --> C[Meters]
        D[JPY] -->|+| E[JPY]
        E --> F[JPY]
    end
 
    subgraph "異なる単位の演算"
        G[Meters] -->|/| H[Seconds]
        H --> I[MetersPerSecond]
        J[USD] -->|×| K[ExchangeRate]
        K --> L[JPY]
    end
 
    subgraph "禁止される演算"
        M[Meters] -.x.-> N[Seconds]
        O[JPY] -.x.-> P[USD]
    end

// ニュートンの第二法則: F = ma
type Newtons = Brand<number, "Newtons">; // 力の単位
type MetersPerSecondSquared = Brand<number, "MetersPerSecondSquared">; // 加速度
 
function calculateForce(
  mass: Kilograms,
  acceleration: MetersPerSecondSquared
): Newtons {
  return ((mass as number) * (acceleration as number)) as Newtons;
}
 
// 重力加速度
const g: MetersPerSecondSquared = 9.8 as MetersPerSecondSquared;
 
// 物体の重量
function weight(mass: Kilograms): Newtons {
  return calculateForce(mass, g);
}
 
// 使用例
const objectMass = kilograms(10);
const objectWeight = weight(objectMass);
console.log(`Weight: ${objectWeight} N`); // Weight: 98 N
 
// 仕事 = 力 × 距離
function calculateWork(force: Newtons, distance: Meters): Joules {
  return ((force as number) * (distance as number)) as Joules;
}
 
const appliedForce = 50 as Newtons;
const distanceMoved = meters(20);
const workDone = calculateWork(appliedForce, distanceMoved);
console.log(`Work: ${workDone} J`); // Work: 1000 J

type UserId = Brand<string, "UserId">;
type Email = Brand<string, "Email">;
 
interface User {
  id: UserId;
  email: Email;
  name: string;
}
 
const user: User = {
  id: "user-123" as UserId,
  email: "alice@example.com" as Email,
  name: "Alice",
};
 
// JSON.stringify は通常通り動作
const json = JSON.stringify(user);
console.log(json);
// {"id":"user-123","email":"alice@example.com","name":"Alice"}
 
// ブランド情報は失われる（ランタイムには存在しないため）

// パース後にバリデーション + ブランド付与が必要
function parseUser(json: string): Result<User, string> {
  let data: unknown;
 
  try {
    data = JSON.parse(json);
  } catch (error) {
    return Err("Invalid JSON");
  }
 
  // 構造チェック
  if (
    typeof data !== "object" ||
    data === null ||
    !("id" in data) ||
    !("email" in data) ||
    !("name" in data)
  ) {
    return Err("Invalid user structure");
  }
 
  const obj = data as { id: unknown; email: unknown; name: unknown };
 
  // 各フィールドのバリデーション
  if (typeof obj.id !== "string") {
    return Err("Invalid id type");
  }
 
  const emailResult = email(String(obj.email));
  if (isErr(emailResult)) {
    return Err(emailResult.error);
  }
 
  if (typeof obj.name !== "string") {
    return Err("Invalid name type");
  }
 
  return Ok({
    id: obj.id as UserId, // 検証済みなのでブランド付与
    email: emailResult.value,
    name: obj.name,
  });
}
 
// 使用例
const jsonString = '{"id":"user-456","email":"bob@example.com","name":"Bob"}';
const userResult = parseUser(jsonString);
 
if (isOk(userResult)) {
  console.log("Parsed user:", userResult.value);
  // userResult.value.id は UserId 型
} else {
  console.error("Parse error:", userResult.error);
}

import { z } from "zod";
 
// ユーザースキーマ
const UserSchema = z.object({
  id: z.string().brand<"UserId">(),
  email: z.string().email().brand<"Email">(),
  name: z.string().min(1),
});
 
type User = z.infer<typeof UserSchema>;
 
// JSON からのパース
function parseUserWithZod(json: string): Result<User, z.ZodError> {
  try {
    const data = JSON.parse(json);
    const result = UserSchema.safeParse(data);
 
    if (result.success) {
      return Ok(result.data);
    } else {
      return Err(result.error);
    }
  } catch {
    return Err(new z.ZodError([{
      code: "custom",
      path: [],
      message: "Invalid JSON",
    }]));
  }
}
 
// 使用例
const jsonString = '{"id":"user-789","email":"charlie@example.com","name":"Charlie"}';
const result = parseUserWithZod(jsonString);
 
if (isOk(result)) {
  const user: User = result.data;
  console.log(user.id); // UserId 型
} else {
  console.error(result.error.flatten());
}

// API レスポンスの型定義
const OrderResponseSchema = z.object({
  id: z.string().uuid().brand<"OrderId">(),
  userId: z.string().uuid().brand<"UserId">(),
  items: z.array(z.object({
    productId: z.string().uuid().brand<"ProductId">(),
    quantity: z.number().int().positive().brand<"Quantity">(),
    priceJPY: z.number().positive().brand<"JPY">(),
  })),
  totalJPY: z.number().positive().brand<"JPY">(),
  status: z.enum(["pending", "paid", "shipped", "delivered"]),
  createdAt: z.string().datetime().transform(d => new Date(d)),
});
 
type OrderResponse = z.infer<typeof OrderResponseSchema>;
 
// API 呼び出し
async function fetchOrder(orderId: OrderId): Promise<Result<OrderResponse, string>> {
  try {
    const response = await fetch(`/api/orders/${orderId}`);
 
    if (!response.ok) {
      return Err(`HTTP error: ${response.status}`);
    }
 
    const json = await response.json();
    const result = OrderResponseSchema.safeParse(json);
 
    if (result.success) {
      return Ok(result.data);
    } else {
      return Err(`Validation error: ${result.error.message}`);
    }
  } catch (error) {
    return Err(`Network error: ${error}`);
  }
}
 
// 使用例
const orderId = "550e8400-e29b-41d4-a716-446655440000" as OrderId;
const orderResult = await fetchOrder(orderId);
 
if (isOk(orderResult)) {
  const order = orderResult.value;
  console.log(`Order total: ¥${order.totalJPY}`);
  // order.totalJPY は JPY 型（ブランド付き）
}

// ブランド型をラップするクラス（高度な使い方）
class BrandedValue<T, B extends string> {
  private readonly _brand!: B;
 
  constructor(public readonly value: T) {}
 
  toJSON(): T {
    return this.value;
  }
 
  static from<T, B extends string>(
    value: T,
    validator?: (v: T) => boolean
  ): Result<BrandedValue<T, B>, string> {
    if (validator && !validator(value)) {
      return Err("Validation failed");
    }
    return Ok(new BrandedValue<T, B>(value));
  }
}
 
// 使用例
const emailValue = BrandedValue.from<string, "Email">(
  "test@example.com",
  (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v)
);
 
if (isOk(emailValue)) {
  const json = JSON.stringify(emailValue.value);
  console.log(json); // "test@example.com"
}

// ブランド型アプローチ
type EmailBranded = Brand<string, "Email">;
 
function emailBranded(value: string): Result<EmailBranded, string> {
  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
    return Err("Invalid email");
  }
  return Ok(value as EmailBranded);
}
 
// class ラッパーアプローチ
class EmailClass {
  private constructor(private readonly value: string) {}
 
  static create(value: string): Result<EmailClass, string> {
    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
      return Err("Invalid email");
    }
    return Ok(new EmailClass(value));
  }
 
  toString(): string {
    return this.value;
  }
 
  toJSON(): string {
    return this.value;
  }
}
 
// 比較
const branded = emailBranded("test@example.com");
const classed = EmailClass.create("test@example.com");
 
// ブランド型: string のメソッドをそのまま使える
if (isOk(branded)) {
  console.log(branded.value.toUpperCase()); // OK
  console.log(branded.value.length); // OK
}
 
// class ラッパー: メソッドを明示的に呼ぶ必要
if (isOk(classed)) {
  // console.log(classed.value.toUpperCase()); // エラー（private）
  console.log(classed.value.toString().toUpperCase()); // OK
}

// enum アプローチ
enum UserRole {
  Admin = "admin",
  User = "user",
  Guest = "guest",
}
 
function processRole(role: UserRole): void {
  switch (role) {
    case UserRole.Admin:
      console.log("Admin access");
      break;
    case UserRole.User:
      console.log("User access");
      break;
    case UserRole.Guest:
      console.log("Guest access");
      break;
  }
}
 
// ブランド型アプローチ（Union 型と組み合わせ）
type UserRole = "admin" | "user" | "guest";
type ValidatedRole = Brand<UserRole, "ValidatedRole">;
 
function validatedRole(role: string): Result<ValidatedRole, string> {
  if (role !== "admin" && role !== "user" && role !== "guest") {
    return Err(`Invalid role: ${role}`);
  }
  return Ok(role as ValidatedRole);
}
 
// enum の方が適している場合
// - 値が固定されている
// - switch 文で網羅性チェックが欲しい
// - リバースマッピングが必要
 
// ブランド型の方が適している場合
// - 動的な値（ID、メールアドレス、URL など）
// - バリデーションが複雑
// - 外部データとの統合

// Flow の opaque type
opaque type UserId = string;
 
function userId(id: string): UserId {
  return id; // キャスト不要
}
 
// 他のモジュールからは UserId の実装が見えない

// Rust の newtype
struct UserId(String);
 
impl UserId {
    fn new(id: String) -> Self {
        UserId(id)
    }
}
 
// 完全に別の型（構造的型付けではない）

// TypeScript のブランド型（擬似 opaque）
type UserId = Brand<string, "UserId">;
 
function userId(id: string): UserId {
  return id as UserId; // キャストが必要
}
 
// 型レベルでのみ区別（ランタイムでは同じ）

// テンプレートリテラル型
type UserId = `user_${string}`;
type OrderId = `order_${string}`;
 
const uid: UserId = "user_123"; // OK
// const bad: UserId = "123"; // エラー
 
// ブランド型
type UserIdBranded = Brand<string, "UserId">;
 
const uidBranded = "anything" as UserIdBranded; // OK（形式チェックなし）
 
// テンプレートリテラル型のメリット
// - リテラル値でも型チェックが効く
// - パターンが明示的
 
// テンプレートリテラル型のデメリット
// - フォーマットが固定される
// - 既存データとの互換性がない場合がある
 
// ブランド型のメリット
// - フォーマットに依存しない
// - 柔軟なバリデーション
 
// ブランド型のデメリット
// - リテラル値では型チェックが効かない

// ❌ NG: バリデーションなしでブランド付与
function unsafeEmail(input: string): Email {
  return input as Email; // 不正な値もブランドが付く
}
 
const badEmail = unsafeEmail("not-an-email");
sendEmail(badEmail); // 実行時エラーの可能性
 
// ✅ OK: スマートコンストラクタで検証
function safeEmail(input: string): Result<Email, string> {
  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)) {
    return Err("Invalid email format");
  }
  return Ok(input as Email);
}
 
const emailResult = safeEmail("test@example.com");
if (isOk(emailResult)) {
  sendEmail(emailResult.value); // 安全
}

// ❌ NG: 全てのプリミティブにブランドを付ける（過剰）
type FirstName = Brand<string, "FirstName">;
type LastName = Brand<string, "LastName">;
type MiddleName = Brand<string, "MiddleName">;
type Street = Brand<string, "Street">;
type City = Brand<string, "City">;
type State = Brand<string, "State">;
type ZipCode = Brand<string, "ZipCode">;
type Country = Brand<string, "Country">;
type PhoneNumber = Brand<string, "PhoneNumber">;
type FaxNumber = Brand<string, "FaxNumber">;
// ... 数十個のブランド型
 
interface Address {
  street: Street;
  city: City;
  state: State;
  zipCode: ZipCode;
  country: Country;
}
 
// ✅ OK: 取り違えが危険な場面のみブランド付与
interface AddressBetter {
  street: string; // 通常の string で十分
  city: string;
  state: string;
  zipCode: string; // または ZipCode（バリデーション必要な場合）
  country: string;
}
 
// ブランド型を使うべき場面:
// - ID 系（UserId, OrderId, ProductId）: 取り違えが危険
// - 単位系（Meters, Seconds, JPY）: 計算ミスが危険
// - バリデーション済み値（Email, Url, NonEmpty）: 再検証を避けたい