// =============================================================
// Maybe モナド: null 安全な計算の連鎖
// =============================================================
 
class Maybe<T> {
  private constructor(private readonly value: T | null) {}
 
  // --- unit (return, of) ---
  static of<T>(value: T): Maybe<T> {
    return new Maybe(value);
  }
 
  static nothing<T>(): Maybe<T> {
    return new Maybe<T>(null);
  }
 
  static fromNullable<T>(value: T | null | undefined): Maybe<T> {
    return value == null ? Maybe.nothing() : Maybe.of(value);
  }
 
  // --- map (Functor) ---
  map<U>(fn: (value: T) => U): Maybe<U> {
    return this.value == null ? Maybe.nothing() : Maybe.of(fn(this.value));
  }
 
  // --- bind (flatMap) ---
  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U> {
    return this.value == null ? Maybe.nothing() : fn(this.value);
  }
 
  // --- apply (Applicative) ---
  apply<U>(maybeFn: Maybe<(value: T) => U>): Maybe<U> {
    return maybeFn.flatMap(fn => this.map(fn));
  }
 
  // --- ユーティリティ ---
  getOrElse(defaultValue: T): T {
    return this.value ?? defaultValue;
  }
 
  getOrThrow(message: string): T {
    if (this.value == null) throw new Error(message);
    return this.value;
  }
 
  filter(predicate: (value: T) => boolean): Maybe<T> {
    if (this.value == null) return Maybe.nothing();
    return predicate(this.value) ? this : Maybe.nothing();
  }
 
  isNothing(): boolean {
    return this.value == null;
  }
 
  isJust(): boolean {
    return this.value != null;
  }
 
  // パターンマッチ
  match<U>(patterns: { just: (value: T) => U; nothing: () => U }): U {
    return this.value != null ? patterns.just(this.value) : patterns.nothing();
  }
 
  // デバッグ用 (副作用を挿入しつつチェーンを維持)
  tap(fn: (value: T) => void): Maybe<T> {
    if (this.value != null) fn(this.value);
    return this;
  }
 
  toString(): string {
    return this.value != null ? `Just(${this.value})` : "Nothing";
  }
}
 
// =============================================================
// モナド則の検証
// =============================================================
const f = (x: number) => Maybe.of(x * 2);
const g = (x: number) => (x > 0 ? Maybe.of(x + 1) : Maybe.nothing<number>());
 
// 左単位元: unit(a).bind(f) === f(a)
console.log(Maybe.of(5).flatMap(f).toString());  // Just(10)
console.log(f(5).toString());                     // Just(10)
 
// 右単位元: m.bind(unit) === m
console.log(Maybe.of(5).flatMap(Maybe.of).toString());  // Just(5)
console.log(Maybe.of(5).toString());                     // Just(5)
 
// 結合則: m.bind(f).bind(g) === m.bind(x => f(x).bind(g))
const m = Maybe.of(3);
console.log(m.flatMap(f).flatMap(g).toString());              // Just(7)
console.log(m.flatMap(x => f(x).flatMap(g)).toString());      // Just(7)
 
// =============================================================
// 実践的な使用例: ネストされたオブジェクトの安全な探索
// =============================================================
interface Company {
  name: string;
  ceo?: {
    name: string;
    address?: {
      city?: string;
      country?: string;
    };
  };
}
 
function getCeoCity(company: Company | null): string {
  return Maybe.fromNullable(company)
    .flatMap(c => Maybe.fromNullable(c.ceo))
    .flatMap(ceo => Maybe.fromNullable(ceo.address))
    .flatMap(addr => Maybe.fromNullable(addr.city))
    .getOrElse("Unknown");
}
 
// テスト
const company1: Company = {
  name: "Acme",
  ceo: { name: "Alice", address: { city: "Tokyo", country: "JP" } }
};
const company2: Company = { name: "Beta" };
const company3: Company = { name: "Gamma", ceo: { name: "Bob" } };
 
console.log(getCeoCity(company1));  // "Tokyo"
console.log(getCeoCity(company2));  // "Unknown" (ceo なし)
console.log(getCeoCity(company3));  // "Unknown" (address なし)
console.log(getCeoCity(null));      // "Unknown" (company なし)
 
// =============================================================
// Maybe + 配列: 安全な検索
// =============================================================
function findFirst<T>(
  items: T[],
  predicate: (item: T) => boolean
): Maybe<T> {
  const found = items.find(predicate);
  return Maybe.fromNullable(found);
}
 
interface Product {
  id: number;
  name: string;
  discount?: number;
}
 
const products: Product[] = [
  { id: 1, name: "Widget", discount: 0.1 },
  { id: 2, name: "Gadget" },
  { id: 3, name: "Doohickey", discount: 0.25 },
];
 
// 割引価格を安全に計算
function getDiscountedPrice(
  products: Product[],
  productId: number,
  basePrice: number
): Maybe<number> {
  return findFirst(products, p => p.id === productId)
    .flatMap(product => Maybe.fromNullable(product.discount))
    .map(discount => basePrice * (1 - discount));
}
 
console.log(getDiscountedPrice(products, 1, 100).toString());  // Just(90)
console.log(getDiscountedPrice(products, 2, 100).toString());  // Nothing (割引なし)
console.log(getDiscountedPrice(products, 9, 100).toString());  // Nothing (商品なし)

// =============================================================
// Either モナド: 型安全なエラーハンドリング
// =============================================================
 
type Either<L, R> =
  | { readonly tag: "Left"; readonly value: L }
  | { readonly tag: "Right"; readonly value: R };
 
// --- コンストラクタ ---
const Left = <L, R = never>(value: L): Either<L, R> => ({
  tag: "Left",
  value,
});
const Right = <R, L = never>(value: R): Either<L, R> => ({
  tag: "Right",
  value,
});
 
// --- モナド操作 (関数スタイル) ---
const EitherM = {
  // unit
  of<R>(value: R): Either<never, R> {
    return Right(value);
  },
 
  // map (Functor)
  map<L, R, U>(either: Either<L, R>, fn: (r: R) => U): Either<L, U> {
    return either.tag === "Right" ? Right(fn(either.value)) : either;
  },
 
  // bind (flatMap)
  flatMap<L, R, U>(
    either: Either<L, R>,
    fn: (r: R) => Either<L, U>
  ): Either<L, U> {
    return either.tag === "Right" ? fn(either.value) : either;
  },
 
  // mapLeft: エラー側を変換
  mapLeft<L, R, U>(either: Either<L, R>, fn: (l: L) => U): Either<U, R> {
    return either.tag === "Left" ? Left(fn(either.value)) : either;
  },
 
  // bimap: 両側を変換
  bimap<L, R, U, V>(
    either: Either<L, R>,
    leftFn: (l: L) => U,
    rightFn: (r: R) => V
  ): Either<U, V> {
    return either.tag === "Left"
      ? Left(leftFn(either.value))
      : Right(rightFn(either.value));
  },
 
  // fold (パターンマッチ)
  fold<L, R, U>(
    either: Either<L, R>,
    onLeft: (l: L) => U,
    onRight: (r: R) => U
  ): U {
    return either.tag === "Left"
      ? onLeft(either.value)
      : onRight(either.value);
  },
 
  // tryCatch: 例外を Either に変換
  tryCatch<R>(fn: () => R): Either<Error, R> {
    try {
      return Right(fn());
    } catch (e) {
      return Left(e instanceof Error ? e : new Error(String(e)));
    }
  },
 
  // fromNullable: null/undefined を Left に変換
  fromNullable<L, R>(
    value: R | null | undefined,
    error: L
  ): Either<L, R> {
    return value == null ? Left(error) : Right(value);
  },
 
  // 複数の Either を結合 (すべて Right なら成功)
  sequence<L, R>(eithers: Either<L, R>[]): Either<L, R[]> {
    const results: R[] = [];
    for (const either of eithers) {
      if (either.tag === "Left") return either;
      results.push(either.value);
    }
    return Right(results);
  },
};
 
// =============================================================
// 鉄道指向プログラミング: バリデーションパイプライン
// =============================================================
 
// 構造化エラー型
interface ValidationError {
  field: string;
  message: string;
  code: string;
}
 
const vError = (
  field: string,
  message: string,
  code: string
): ValidationError => ({ field, message, code });
 
// 各バリデーション関数は Either を返す
function validateEmail(
  email: string
): Either<ValidationError, string> {
  if (!email.includes("@")) {
    return Left(vError("email", "Must contain @", "INVALID_EMAIL"));
  }
  if (email.length < 5) {
    return Left(vError("email", "Too short", "EMAIL_TOO_SHORT"));
  }
  return Right(email.toLowerCase().trim());
}
 
function validatePassword(
  password: string
): Either<ValidationError, string> {
  if (password.length < 8) {
    return Left(vError("password", "Min 8 chars", "PASSWORD_TOO_SHORT"));
  }
  if (!/[A-Z]/.test(password)) {
    return Left(vError("password", "Need uppercase", "PASSWORD_NO_UPPER"));
  }
  if (!/[0-9]/.test(password)) {
    return Left(vError("password", "Need digit", "PASSWORD_NO_DIGIT"));
  }
  return Right(password);
}
 
function validateAge(age: number): Either<ValidationError, number> {
  if (!Number.isInteger(age)) {
    return Left(vError("age", "Must be integer", "AGE_NOT_INTEGER"));
  }
  if (age < 13 || age > 120) {
    return Left(vError("age", "Must be 13-120", "AGE_OUT_OF_RANGE"));
  }
  return Right(age);
}
 
function validateUsername(
  name: string
): Either<ValidationError, string> {
  if (name.length < 3) {
    return Left(vError("username", "Min 3 chars", "USERNAME_TOO_SHORT"));
  }
  if (!/^[a-zA-Z0-9_]+$/.test(name)) {
    return Left(vError("username", "Alphanumeric only", "USERNAME_INVALID"));
  }
  return Right(name);
}
 
// --- 鉄道: 最初のエラーで停止 ---
interface RegistrationInput {
  username: string;
  email: string;
  password: string;
  age: number;
}
 
interface ValidatedUser {
  username: string;
  email: string;
  password: string;
  age: number;
}
 
function validateRegistration(
  input: RegistrationInput
): Either<ValidationError, ValidatedUser> {
  // 各ステップが Left を返した時点でパイプライン全体が Left になる
  const username = validateUsername(input.username);
  const email = EitherM.flatMap(username, () => validateEmail(input.email));
  const password = EitherM.flatMap(email, () => validatePassword(input.password));
  const age = EitherM.flatMap(password, () => validateAge(input.age));
 
  return EitherM.map(age, () => ({
    username: input.username,
    email: input.email.toLowerCase().trim(),
    password: input.password,
    age: input.age,
  }));
}
 
// テスト
const good = validateRegistration({
  username: "alice",
  email: "alice@example.com",
  password: "Secret123",
  age: 25,
});
console.log(good);
// { tag: "Right", value: { username: "alice", email: "alice@example.com", ... } }
 
const bad = validateRegistration({
  username: "al",
  email: "alice@example.com",
  password: "Secret123",
  age: 25,
});
console.log(bad);
// { tag: "Left", value: { field: "username", message: "Min 3 chars", code: "USERNAME_TOO_SHORT" } }
 
// --- 鉄道: すべてのエラーを収集 (Validation モナド) ---
function validateAllErrors(
  input: RegistrationInput
): Either<ValidationError[], ValidatedUser> {
  const results = [
    EitherM.mapLeft(validateUsername(input.username), e => [e]),
    EitherM.mapLeft(validateEmail(input.email), e => [e]),
    EitherM.mapLeft(validatePassword(input.password), e => [e]),
    EitherM.mapLeft(validateAge(input.age), e => [e]),
  ];
 
  const errors: ValidationError[] = [];
  for (const result of results) {
    if (result.tag === "Left") {
      errors.push(...result.value);
    }
  }
 
  if (errors.length > 0) return Left(errors);
 
  return Right({
    username: input.username,
    email: input.email.toLowerCase().trim(),
    password: input.password,
    age: input.age,
  });
}
 
const allBad = validateAllErrors({
  username: "al",
  email: "bad",
  password: "weak",
  age: 5,
});
console.log(allBad);
// { tag: "Left", value: [
//   { field: "username", message: "Min 3 chars", ... },
//   { field: "email", message: "Must contain @", ... },
//   { field: "password", message: "Min 8 chars", ... },
//   { field: "age", message: "Must be 13-120", ... }
// ] }

// =============================================================
// Result<T, E>: Rust スタイルの型安全エラーハンドリング
// =============================================================
 
class Result<T, E> {
  private constructor(
    private readonly _ok: boolean,
    private readonly _value: T | undefined,
    private readonly _error: E | undefined
  ) {}
 
  static ok<T, E = never>(value: T): Result<T, E> {
    return new Result<T, E>(true, value, undefined);
  }
 
  static err<E, T = never>(error: E): Result<T, E> {
    return new Result<T, E>(false, undefined, error);
  }
 
  static fromTryCatch<T>(fn: () => T): Result<T, Error> {
    try {
      return Result.ok(fn());
    } catch (e) {
      return Result.err(e instanceof Error ? e : new Error(String(e)));
    }
  }
 
  static async fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>> {
    try {
      return Result.ok(await promise);
    } catch (e) {
      return Result.err(e instanceof Error ? e : new Error(String(e)));
    }
  }
 
  isOk(): boolean {
    return this._ok;
  }
 
  isErr(): boolean {
    return !this._ok;
  }
 
  // --- Functor ---
  map<U>(fn: (value: T) => U): Result<U, E> {
    return this._ok
      ? Result.ok(fn(this._value as T))
      : Result.err(this._error as E);
  }
 
  mapErr<F>(fn: (error: E) => F): Result<T, F> {
    return this._ok
      ? Result.ok(this._value as T)
      : Result.err(fn(this._error as E));
  }
 
  // --- Monad ---
  flatMap<U>(fn: (value: T) => Result<U, E>): Result<U, E> {
    return this._ok
      ? fn(this._value as T)
      : Result.err(this._error as E);
  }
 
  // --- 値の取得 ---
  unwrap(): T {
    if (!this._ok) throw new Error("Called unwrap on Err");
    return this._value as T;
  }
 
  unwrapOr(defaultValue: T): T {
    return this._ok ? (this._value as T) : defaultValue;
  }
 
  unwrapOrElse(fn: (error: E) => T): T {
    return this._ok ? (this._value as T) : fn(this._error as E);
  }
 
  unwrapErr(): E {
    if (this._ok) throw new Error("Called unwrapErr on Ok");
    return this._error as E;
  }
 
  // --- パターンマッチ ---
  match<U>(patterns: { ok: (value: T) => U; err: (error: E) => U }): U {
    return this._ok
      ? patterns.ok(this._value as T)
      : patterns.err(this._error as E);
  }
 
  // --- 合成 ---
  and<U>(other: Result<U, E>): Result<U, E> {
    return this._ok ? other : Result.err(this._error as E);
  }
 
  or(other: Result<T, E>): Result<T, E> {
    return this._ok ? this : other;
  }
 
  // --- 変換 ---
  toMaybe(): Maybe<T> {
    return this._ok ? Maybe.of(this._value as T) : Maybe.nothing();
  }
 
  toString(): string {
    return this._ok
      ? `Ok(${JSON.stringify(this._value)})`
      : `Err(${JSON.stringify(this._error)})`;
  }
}
 
// =============================================================
// 実践例: JSON パース -> バリデーション -> ビジネスロジック
// =============================================================
 
interface Config {
  host: string;
  port: number;
  maxRetries: number;
}
 
function parseJson(raw: string): Result<unknown, string> {
  return Result.fromTryCatch(() => JSON.parse(raw))
    .mapErr(e => `JSON parse error: ${e.message}`);
}
 
function validateConfig(data: unknown): Result<Config, string> {
  if (typeof data !== "object" || data === null) {
    return Result.err("Config must be an object");
  }
  const obj = data as Record<string, unknown>;
  if (typeof obj.host !== "string") {
    return Result.err("host must be a string");
  }
  if (typeof obj.port !== "number" || obj.port < 1 || obj.port > 65535) {
    return Result.err("port must be 1-65535");
  }
  if (typeof obj.maxRetries !== "number" || obj.maxRetries < 0) {
    return Result.err("maxRetries must be non-negative");
  }
  return Result.ok({
    host: obj.host as string,
    port: obj.port as number,
    maxRetries: obj.maxRetries as number,
  });
}
 
function normalizeConfig(config: Config): Result<Config, string> {
  if (config.host === "localhost") {
    return Result.ok({ ...config, host: "127.0.0.1" });
  }
  if (config.host.length === 0) {
    return Result.err("host cannot be empty");
  }
  return Result.ok(config);
}
 
// flatMap の連鎖 = 鉄道指向パイプライン
function loadConfig(raw: string): Result<Config, string> {
  return parseJson(raw)
    .flatMap(validateConfig)
    .flatMap(normalizeConfig);
}
 
// テスト
console.log(loadConfig('{"host":"localhost","port":8080,"maxRetries":3}').toString());
// Ok({"host":"127.0.0.1","port":8080,"maxRetries":3})
 
console.log(loadConfig('{"host":"","port":8080,"maxRetries":3}').toString());
// Err("host cannot be empty")
 
console.log(loadConfig("not json").toString());
// Err("JSON parse error: ...")
 
console.log(loadConfig('{"host":"example.com","port":99999,"maxRetries":3}').toString());
// Err("port must be 1-65535")

// =============================================================
// IO モナド: 副作用の遅延実行と合成
// =============================================================
 
// IO は「副作用を持つ計算」を値として扱う
// 実行されるまで副作用は発生しない (参照透過性の維持)
class IO<T> {
  constructor(private readonly effect: () => T) {}
 
  // --- unit ---
  static of<T>(value: T): IO<T> {
    return new IO(() => value);
  }
 
  // --- Functor ---
  map<U>(fn: (value: T) => U): IO<U> {
    return new IO(() => fn(this.effect()));
  }
 
  // --- Monad ---
  flatMap<U>(fn: (value: T) => IO<U>): IO<U> {
    return new IO(() => fn(this.effect()).run());
  }
 
  // 副作用を実行
  run(): T {
    return this.effect();
  }
 
  // 2つの IO を順次実行
  andThen<U>(next: IO<U>): IO<U> {
    return this.flatMap(() => next);
  }
 
  // デバッグ用
  tap(fn: (value: T) => void): IO<T> {
    return new IO(() => {
      const result = this.effect();
      fn(result);
      return result;
    });
  }
}
 
// --- IO ユーティリティ ---
const ConsoleIO = {
  log(message: string): IO<void> {
    return new IO(() => console.log(message));
  },
  readLine(prompt: string): IO<string> {
    // 実際の readline 実装は省略
    return new IO(() => {
      console.log(prompt);
      return "simulated-input";
    });
  },
  currentTime(): IO<Date> {
    return new IO(() => new Date());
  },
  randomInt(min: number, max: number): IO<number> {
    return new IO(() => Math.floor(Math.random() * (max - min + 1)) + min);
  },
};
 
// =============================================================
// IO の合成: プログラム全体を純粋に記述
// =============================================================
 
// このプログラム定義自体は純粋 (副作用なし)
const greetProgram: IO<void> = ConsoleIO.currentTime()
  .map(date => date.toISOString())
  .flatMap(time =>
    ConsoleIO.log(`[${time}] Hello!`)
      .andThen(ConsoleIO.log(`[${time}] Welcome to IO Monad`))
  );
 
// run() を呼ぶまで何も起きない
// greetProgram.run();  // 実行時にのみ副作用が発生
 
// =============================================================
// 比較: IO vs 直接副作用
// =============================================================
 
// [NG] 直接副作用 --- テスト困難
function greetDirect(): void {
  const time = new Date().toISOString();  // 副作用: 現在時刻
  console.log(`[${time}] Hello!`);        // 副作用: コンソール出力
  console.log(`[${time}] Welcome`);       // 副作用: コンソール出力
}
 
// [OK] IO モナド --- テスト可能
function greetIO(
  getTime: () => IO<Date>,
  log: (msg: string) => IO<void>
): IO<void> {
  return getTime()
    .map(date => date.toISOString())
    .flatMap(time =>
      log(`[${time}] Hello!`)
        .andThen(log(`[${time}] Welcome`))
    );
}
 
// テスト時: モック IO を注入
const logs: string[] = [];
const mockGetTime = () => IO.of(new Date("2025-01-01T00:00:00Z"));
const mockLog = (msg: string) => new IO(() => { logs.push(msg); });
 
greetIO(mockGetTime, mockLog).run();
console.log(logs);
// ["[2025-01-01T00:00:00.000Z] Hello!", "[2025-01-01T00:00:00.000Z] Welcome"]
 
// =============================================================
// Promise = 非同期 IO モナド
// async/await = do 記法の糖衣構文
// =============================================================
 
// Promise のモナド的性質
// then = flatMap (bind)
// Promise.resolve = unit
 
// [モナディックスタイル (then チェーン)]
function fetchUserOrdersChain(userId: string): Promise<OrderSummary> {
  return fetchUser(userId)                                // Promise<User>
    .then(user => fetchOrders(user.id))                   // flatMap: User -> Promise<Order[]>
    .then(orders => orders.filter(o => o.active))         // map: Order[] -> Order[]
    .then(orders => ({
      userId,
      totalOrders: orders.length,
      totalAmount: orders.reduce((sum, o) => sum + o.amount, 0),
    }));
}
 
// [do 記法スタイル (async/await)]
async function fetchUserOrdersAwait(userId: string): Promise<OrderSummary> {
  const user = await fetchUser(userId);                    // bind
  const orders = await fetchOrders(user.id);               // bind
  const activeOrders = orders.filter(o => o.active);       // 純粋計算
 
  return {                                                 // unit (return)
    userId,
    totalOrders: activeOrders.length,
    totalAmount: activeOrders.reduce((sum, o) => sum + o.amount, 0),
  };
}
 
// 型定義 (上記コード用)
interface OrderSummary {
  userId: string;
  totalOrders: number;
  totalAmount: number;
}
 
declare function fetchUser(id: string): Promise<{ id: string; name: string }>;
declare function fetchOrders(userId: string): Promise<Array<{ active: boolean; amount: number }>>;

// =============================================================
// List モナド: 非決定性計算
// flatMap = 各要素に関数を適用してフラットに
// =============================================================
 
// Array は実は List モナド
// Array.prototype.flatMap が bind に相当
 
// 例: チェスのナイトの移動
type Position = [number, number];
 
function knightMoves([x, y]: Position): Position[] {
  const deltas: Position[] = [
    [2, 1], [2, -1], [-2, 1], [-2, -1],
    [1, 2], [1, -2], [-1, 2], [-1, -2],
  ];
  return deltas
    .map(([dx, dy]) => [x + dx, y + dy] as Position)
    .filter(([nx, ny]) => nx >= 1 && nx <= 8 && ny >= 1 && ny <= 8);
}
 
// 3手後に到達可能なすべての位置 (List モナドの flatMap)
function knightReachableIn3(start: Position): Position[] {
  return [start]
    .flatMap(knightMoves)   // 1手目: すべての可能な位置
    .flatMap(knightMoves)   // 2手目: さらにすべての可能な位置
    .flatMap(knightMoves);  // 3手目: さらに
}
 
console.log(`(1,1) から3手で到達可能: ${knightReachableIn3([1, 1]).length} 通り`);
 
// List Comprehension としての flatMap
// Haskell: [(x, y) | x <- [1..3], y <- [1..3], x /= y]
// Python:  [(x, y) for x in range(1,4) for y in range(1,4) if x != y]
const pairs = [1, 2, 3]
  .flatMap(x => [1, 2, 3]
  );
console.log(pairs); // [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]
 
// =============================================================
// Reader モナド: 依存性注入
// =============================================================
 
// Reader<E, A> は E -> A の関数をラップしたモナド
// 環境 E を暗黙的に引き回す
class Reader<E, A> {
  constructor(public readonly run: (env: E) => A) {}
 
  static of<E, A>(value: A): Reader<E, A> {
    return new Reader(() => value);
  }
 
  // 環境そのものを取得
  static ask<E>(): Reader<E, E> {
    return new Reader(env => env);
  }
 
  // 環境の一部を取得
  static asks<E, A>(fn: (env: E) => A): Reader<E, A> {
    return new Reader(fn);
  }
 
  map<B>(fn: (a: A) => B): Reader<E, B> {
    return new Reader(env => fn(this.run(env)));
  }
 
  flatMap<B>(fn: (a: A) => Reader<E, B>): Reader<E, B> {
    return new Reader(env => fn(this.run(env)).run(env));
  }
}
 
// 実践例: 設定と DB 接続を引き回す
interface AppEnv {
  db: { query: (sql: string) => string[] };
  config: { maxResults: number; locale: string };
  logger: { info: (msg: string) => void };
}
 
const getUsers: Reader<AppEnv, string[]> =
  Reader.asks((env: AppEnv) => env.db.query("SELECT * FROM users"));
 
const getMaxResults: Reader<AppEnv, number> =
  Reader.asks((env: AppEnv) => env.config.maxResults);
 
const getLocale: Reader<AppEnv, string> =
  Reader.asks((env: AppEnv) => env.config.locale);
 
// flatMap で Reader を合成 --- 環境は暗黙的に引き回される
const getUserReport: Reader<AppEnv, string> = getUsers
  .flatMap(users =>
    getMaxResults.flatMap(max =>
      getLocale.map(locale => {
        const limited = users.slice(0, max);
        return `[${locale}] Found ${limited.length} users (max: ${max})`;
      })
    )
  );
 
// 実行: 環境を一箇所で注入
const env: AppEnv = {
  db: { query: () => ["Alice", "Bob", "Charlie", "Dave", "Eve"] },
  config: { maxResults: 3, locale: "ja-JP" },
  logger: { info: console.log },
};
 
console.log(getUserReport.run(env));
// "[ja-JP] Found 3 users (max: 3)"
 
// テスト: モック環境で実行
const testEnv: AppEnv = {
  db: { query: () => ["TestUser"] },
  config: { maxResults: 10, locale: "en-US" },
  logger: { info: () => {} },
};
 
console.log(getUserReport.run(testEnv));
// "[en-US] Found 1 users (max: 10)"

"""
Python でのモナド実装
=====================
Python は静的型が弱いため、Haskell や TypeScript ほど厳密な
モナド実装は一般的でないが、同じ概念は dataclass + Protocol で表現できる。
"""
 
from __future__ import annotations
from dataclasses import dataclass
from typing import TypeVar, Generic, Callable, Optional, Union
from abc import ABC, abstractmethod
 
T = TypeVar("T")
U = TypeVar("U")
E = TypeVar("E")
 
# =============================================================
# Maybe モナド
# =============================================================
 
class Maybe(ABC, Generic[T]):
    """Maybe モナド: 値がないかもしれない計算"""
 
    @staticmethod
    def of(value: T) -> "Just[T]":
        return Just(value)
 
    @staticmethod
    def nothing() -> "Nothing[T]":
        return Nothing()
 
    @staticmethod
    def from_optional(value: Optional[T]) -> "Maybe[T]":
        if value is None:
            return Nothing()
        return Just(value)
 
    @abstractmethod
    def map(self, fn: Callable[[T], U]) -> "Maybe[U]": ...
 
    @abstractmethod
    def flat_map(self, fn: Callable[[T], "Maybe[U]"]) -> "Maybe[U]": ...
 
    @abstractmethod
    def get_or_else(self, default: T) -> T: ...
 
    @abstractmethod
    def is_just(self) -> bool: ...
 
 
@dataclass(frozen=True)
class Just(Maybe[T]):
    _value: T
 
    def map(self, fn: Callable[[T], U]) -> Maybe[U]:
        return Just(fn(self._value))
 
    def flat_map(self, fn: Callable[[T], Maybe[U]]) -> Maybe[U]:
        return fn(self._value)
 
    def get_or_else(self, default: T) -> T:
        return self._value
 
    def is_just(self) -> bool:
        return True
 
    def __repr__(self) -> str:
        return f"Just({self._value!r})"
 
 
@dataclass(frozen=True)
class Nothing(Maybe[T]):
    def map(self, fn: Callable[[T], U]) -> Maybe[U]:
        return Nothing()
 
    def flat_map(self, fn: Callable[[T], Maybe[U]]) -> Maybe[U]:
        return Nothing()
 
    def get_or_else(self, default: T) -> T:
        return default
 
    def is_just(self) -> bool:
        return False
 
    def __repr__(self) -> str:
        return "Nothing()"
 
 
# 使用例
def safe_div(a: float, b: float) -> Maybe[float]:
    if b == 0:
        return Nothing()
    return Just(a / b)
 
def safe_sqrt(x: float) -> Maybe[float]:
    if x < 0:
        return Nothing()
    return Just(x ** 0.5)
 
# flatMap の連鎖
result = (
    safe_div(100, 4)          # Just(25.0)
    .flat_map(safe_sqrt)      # Just(5.0)
    .map(lambda x: x * 2)    # Just(10.0)
)
print(result)  # Just(10.0)
 
result_err = (
    safe_div(100, 0)          # Nothing()
    .flat_map(safe_sqrt)      # Nothing() (スキップ)
    .map(lambda x: x * 2)    # Nothing() (スキップ)
)
print(result_err)  # Nothing()
 
 
# =============================================================
# Result モナド
# =============================================================
 
class Result(ABC, Generic[T, E]):
    """Result モナド: 成功か失敗かの計算"""
 
    @staticmethod
    def ok(value: T) -> "Ok[T, E]":
        return Ok(value)
 
    @staticmethod
    def err(error: E) -> "Err[T, E]":
        return Err(error)
 
    @staticmethod
    def from_try(fn: Callable[[], T]) -> "Result[T, Exception]":
        try:
            return Ok(fn())
        except Exception as e:
            return Err(e)
 
    @abstractmethod
    def map(self, fn: Callable[[T], U]) -> "Result[U, E]": ...
 
    @abstractmethod
    def flat_map(self, fn: Callable[[T], "Result[U, E]"]) -> "Result[U, E]": ...
 
    @abstractmethod
    def map_err(self, fn: Callable[[E], object]) -> "Result[T, object]": ...
 
    @abstractmethod
    def unwrap_or(self, default: T) -> T: ...
 
    @abstractmethod
    def is_ok(self) -> bool: ...
 
 
@dataclass(frozen=True)
class Ok(Result[T, E]):
    _value: T
 
    def map(self, fn: Callable[[T], U]) -> Result[U, E]:
        return Ok(fn(self._value))
 
    def flat_map(self, fn: Callable[[T], Result[U, E]]) -> Result[U, E]:
        return fn(self._value)
 
    def map_err(self, fn: Callable[[E], object]) -> Result[T, object]:
        return Ok(self._value)
 
    def unwrap_or(self, default: T) -> T:
        return self._value
 
    def is_ok(self) -> bool:
        return True
 
    def __repr__(self) -> str:
        return f"Ok({self._value!r})"
 
 
@dataclass(frozen=True)
class Err(Result[T, E]):
    _error: E
 
    def map(self, fn: Callable[[T], U]) -> Result[U, E]:
        return Err(self._error)
 
    def flat_map(self, fn: Callable[[T], Result[U, E]]) -> Result[U, E]:
        return Err(self._error)
 
    def map_err(self, fn: Callable[[E], object]) -> Result[T, object]:
        return Err(fn(self._error))
 
    def unwrap_or(self, default: T) -> T:
        return default
 
    def is_ok(self) -> bool:
        return False
 
    def __repr__(self) -> str:
        return f"Err({self._error!r})"
 
 
# 実践例: ファイル処理パイプライン
import json
 
def read_file(path: str) -> Result[str, str]:
    try:
        with open(path) as f:
            return Ok(f.read())
    except FileNotFoundError:
        return Err(f"File not found: {path}")
    except PermissionError:
        return Err(f"Permission denied: {path}")
 
def parse_json(content: str) -> Result[dict, str]:
    try:
        return Ok(json.loads(content))
    except json.JSONDecodeError as e:
        return Err(f"JSON error: {e}")
 
def extract_field(data: dict, field: str) -> Result[object, str]:
    if field not in data:
        return Err(f"Missing field: {field}")
    return Ok(data[field])
 
# 鉄道指向パイプライン
def get_config_value(path: str, field: str) -> Result[object, str]:
    return (
        read_file(path)
        .flat_map(parse_json)
        .flat_map(lambda data: extract_field(data, field))
    )
 
# テスト
# result = get_config_value("config.json", "database_url")
# print(result)
 
 
# =============================================================
# Python 特有: コンテキストマネージャもモナド的
# =============================================================
from contextlib import contextmanager
 
@contextmanager
def managed_connection(url: str):
    """コンテキストマネージャ = Resource モナドの一種"""
    conn = f"Connection({url})"
    print(f"Opening {conn}")
    try:
        yield conn
    finally:
        print(f"Closing {conn}")
 
# with 文 = do 記法の糖衣構文
# with managed_connection("db://localhost") as conn:
#     print(f"Using {conn}")

// =============================================================
// モナド合成: 複数のモナドを組み合わせる実践パターン
// =============================================================
 
// --- 基本型定義 ---
type Result<T, E = Error> =
  | { readonly ok: true; readonly value: T }
  | { readonly ok: false; readonly error: E };
 
const Ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const Err = <E>(error: E): Result<never, E> => ({ ok: false, error });
 
// --- ResultT<Promise>: Promise + Result のモナドトランスフォーマー ---
// 「非同期で、失敗するかもしれない計算」を合成可能にする
 
class AsyncResult<T, E = Error> {
  constructor(private readonly promise: Promise<Result<T, E>>) {}
 
  // --- unit ---
  static of<T>(value: T): AsyncResult<T, never> {
    return new AsyncResult(Promise.resolve(Ok(value)));
  }
 
  static err<E>(error: E): AsyncResult<never, E> {
    return new AsyncResult(Promise.resolve(Err(error)));
  }
 
  // Promise<T> を安全にラップ
  static fromPromise<T>(promise: Promise<T>): AsyncResult<T, Error> {
    return new AsyncResult(
      promise
        .then(value => Ok(value) as Result<T, Error>)
        .catch(e => Err(e instanceof Error ? e : new Error(String(e))))
    );
  }
 
  // --- Functor ---
  map<U>(fn: (value: T) => U): AsyncResult<U, E> {
    return new AsyncResult(
      this.promise.then(result =>
        result.ok ? Ok(fn(result.value)) : result
      )
    );
  }
 
  mapErr<F>(fn: (error: E) => F): AsyncResult<T, F> {
    return new AsyncResult(
      this.promise.then(result =>
        result.ok ? result : Err(fn(result.error))
      )
    );
  }
 
  // --- Monad ---
  flatMap<U>(fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {
    return new AsyncResult(
      this.promise.then(result =>
        result.ok ? fn(result.value).toPromise() : result
      )
    );
  }
 
  // --- ユーティリティ ---
  async toPromise(): Promise<Result<T, E>> {
    return this.promise;
  }
 
  async unwrapOr(defaultValue: T): Promise<T> {
    const result = await this.promise;
    return result.ok ? result.value : defaultValue;
  }
 
  // タイムアウト付き
  withTimeout(ms: number): AsyncResult<T, E | Error> {
    const timeout = new Promise<Result<T, E | Error>>(resolve =>
      setTimeout(() => resolve(Err(new Error(`Timeout: ${ms}ms`))), ms)
    );
    return new AsyncResult(Promise.race([this.promise as Promise<Result<T, E | Error>>, timeout]));
  }
 
  // リトライ
  retry(times: number, delayMs: number = 0): AsyncResult<T, E> {
    return new AsyncResult(
      this.promise.then(async result => {
        if (result.ok || times <= 0) return result;
        if (delayMs > 0) {
          await new Promise(resolve => setTimeout(resolve, delayMs));
        }
        return this.retry(times - 1, delayMs).toPromise();
      })
    );
  }
}
 
// =============================================================
// 実践例: API クライアント
// =============================================================
 
interface User {
  id: string;
  name: string;
  teamId: string;
}
 
interface Team {
  id: string;
  name: string;
  projectIds: string[];
}
 
interface Project {
  id: string;
  title: string;
  budget: number;
}
 
// API 関数 (各呼び出しは非同期 + 失敗可能)
function fetchUserById(id: string): AsyncResult<User, string> {
  return AsyncResult.fromPromise(
    fetch(`/api/users/${id}`).then(r => {
      if (!r.ok) throw new Error(`User not found: ${id}`);
      return r.json();
    })
  ).mapErr(e => `Failed to fetch user: ${e.message}`);
}
 
function fetchTeamById(id: string): AsyncResult<Team, string> {
  return AsyncResult.fromPromise(
    fetch(`/api/teams/${id}`).then(r => {
      if (!r.ok) throw new Error(`Team not found: ${id}`);
      return r.json();
    })
  ).mapErr(e => `Failed to fetch team: ${e.message}`);
}
 
function fetchProjectById(id: string): AsyncResult<Project, string> {
  return AsyncResult.fromPromise(
    fetch(`/api/projects/${id}`).then(r => {
      if (!r.ok) throw new Error(`Project not found: ${id}`);
      return r.json();
    })
  ).mapErr(e => `Failed to fetch project: ${e.message}`);
}
 
// flatMap の連鎖: エラーは自動的に伝播
async function getUserTeamBudget(userId: string): Promise<Result<number, string>> {
  return fetchUserById(userId)
    .flatMap(user => fetchTeamById(user.teamId))
    .flatMap(team => {
      if (team.projectIds.length === 0) {
        return AsyncResult.err("Team has no projects");
      }
      return fetchProjectById(team.projectIds[0]);
    })
    .map(project => project.budget)
    .withTimeout(5000)
    .mapErr(e => typeof e === "string" ? e : e.message)
    .toPromise();
}
 
// =============================================================
// do 記法スタイル: ジェネレータベースの合成
// =============================================================
 
// ジェネレータを使った「do 記法」の疑似実装
function* doResult<T>(): Generator<Result<any, any>, T, any> {
  // ジェネレータ内で yield で Result を「束縛」
  // Left/Err が返った時点でジェネレータを中断
  return undefined as T;
}
 
// 実用的な do 記法 (runDo)
function runDo<T, E>(
  gen: () => Generator<Result<T, E>, T, T>
): Result<T, E> {
  const iterator = gen();
  let next = iterator.next();
 
  while (!next.done) {
    const result = next.value;
    if (!result.ok) {
      return result;  // エラーならジェネレータを中断
    }
    next = iterator.next(result.value);
  }
 
  return Ok(next.value);
}
 
// do 記法での使用例
function processOrder(orderId: string): Result<string, string> {
  return runDo(function* () {
    const parsed = yield parseOrderId(orderId);         // bind
    const order = yield findOrder(parsed);               // bind
    const validated = yield validateOrder(order);         // bind
    return `Processed: ${validated.id}`;                 // return
  });
}
 
// 型定義用ダミー
declare function parseOrderId(id: string): Result<number, string>;
declare function findOrder(id: number): Result<{ id: number; total: number }, string>;
declare function validateOrder(order: { id: number; total: number }): Result<{ id: number; total: number }, string>;
 
// =============================================================
// MaybeT: Maybe + Promise のトランスフォーマー
// =============================================================
 
class MaybeAsync<T> {
  constructor(private readonly promise: Promise<Maybe<T>>) {}
 
  static of<T>(value: T): MaybeAsync<T> {
    return new MaybeAsync(Promise.resolve(Maybe.of(value)));
  }
 
  static nothing<T>(): MaybeAsync<T> {
    return new MaybeAsync(Promise.resolve(Maybe.nothing()));
  }
 
  static fromPromise<T>(promise: Promise<T | null | undefined>): MaybeAsync<T> {
    return new MaybeAsync(
      promise
        .then(v => Maybe.fromNullable(v))
        .catch(() => Maybe.nothing())
    );
  }
 
  map<U>(fn: (value: T) => U): MaybeAsync<U> {
    return new MaybeAsync(this.promise.then(m => m.map(fn)));
  }
 
  flatMap<U>(fn: (value: T) => MaybeAsync<U>): MaybeAsync<U> {
    return new MaybeAsync(
      this.promise.then(m =>
        m.match({
          just: value => fn(value).toPromise(),
          nothing: () => Promise.resolve(Maybe.nothing<U>()),
        })
      )
    );
  }
 
  async toPromise(): Promise<Maybe<T>> {
    return this.promise;
  }
 
  async getOrElse(defaultValue: T): Promise<T> {
    const m = await this.promise;
    return m.getOrElse(defaultValue);
  }
}
 
// 使用例: 非同期 + null の両方を扱う
async function findUserAvatar(userId: string): Promise<string> {
  return MaybeAsync.fromPromise(fetchUserMaybe(userId))
    .flatMap(user =>
      MaybeAsync.fromPromise(fetchProfileMaybe(user.profileId))
    )
    .map(profile => profile.avatarUrl)
    .getOrElse("/default-avatar.png");
}
 
declare function fetchUserMaybe(id: string): Promise<{ profileId: string } | null>;
declare function fetchProfileMaybe(id: string): Promise<{ avatarUrl: string } | null>;