-- Maybe：可能缺失的值
safeHead :: [a] -> Maybe a
safeHead []    = Nothing
safeHead (x:_) = Just x

safeDivide :: Int -> Int -> Maybe Int
safeDivide _ 0 = Nothing
safeDivide a b = Just (a `div` b)

-- 链式调用
calculation :: Int -> Maybe Int
calculation x = do
  a <- safeDivide x 2
  b <- safeDivide a 3
  return (a + b)

-- 或使用 >>= 链式
calculation' :: Int -> Maybe Int
calculation' x =
  safeDivide x 2 >>= \a ->
  safeDivide a 3 >>= \b ->
  return (a + b)

fn safe_head<T>(items: &[T]) -> Option<&T> {
    items.first()
}

fn safe_divide(a: i32, b: i32) -> Option<i32> {
    if b == 0 { None } else { Some(a / b) }
}

// 使用 ? 运算符链接
fn calculation(x: i32) -> Option<i32> {
    let a = safe_divide(x, 2)?;
    let b = safe_divide(a, 3)?;
    Some(a + b)
}

// 组合操作
let result = Some(10)
    .filter(|&x| x > 5)
    .map(|x| x * 2)
    .unwrap_or(0);
// result = 20

class Option {
  static some(value) { return new Some(value); }
  static none() { return new None(); }
  static from(value) {
    return value === null || value === undefined ? Option.none() : Option.some(value);
  }
}

class Some extends Option {
  constructor(value) { super(); this.value = value; }
  map(fn) { return Option.some(fn(this.value)); }
  flatMap(fn) { return fn(this.value); }
  filter(pred) { return pred(this.value) ? this : Option.none(); }
  getOrElse(defaultValue) { return this.value; }
  isSome() { return true; }
}

class None extends Option {
  map(fn) { return this; }
  flatMap(fn) { return this; }
  filter(pred) { return this; }
  getOrElse(defaultValue) { return defaultValue; }
  isSome() { return false; }
}

data Either a b = Left a | Right b

-- Right 表示成功，Left 表示失败
type Result = Either String

validateAge :: Int -> Result Int
validateAge age
  | age < 0   = Left "Age cannot be negative"
  | age > 150 = Left "Age cannot exceed 150"
  | otherwise = Right age

validateEmail :: String -> Result String
validateEmail email
  | '@' `elem` email = Right email
  | otherwise        = Left "Invalid email"

-- 组合验证
validateUser :: String -> Int -> Either String (String, Int)
validateUser email age = do
  validEmail <- validateEmail email
  validAge   <- validateAge age
  return (validEmail, validAge)

-- 结果
validateUser "alice@example.com" 30  -- Right ("alice@example.com", 30)
validateUser "invalid" (-1)          -- Left "Invalid email"（短路）

fn validate_age(age: i32) -> Result<i32, String> {
    if age < 0 { Err("Age cannot be negative".into()) }
    else if age > 150 { Err("Age cannot exceed 150".into()) }
    else { Ok(age) }
}

fn validate_email(email: &str) -> Result<String, String> {
    if email.contains('@') { Ok(email.to_string()) }
    else { Err("Invalid email".into()) }
}

fn validate_user(email: &str, age: i32) -> Result<(String, i32), String> {
    let valid_email = validate_email(email)?;
    let valid_age = validate_age(age)?;
    Ok((valid_email, valid_age))
}

// 使用
match validate_user("alice@example.com", 30) {
    Ok((email, age)) => println!("Valid: {} ({})", email, age),
    Err(err) => println!("Error: {}", err),
}

class Left {
  constructor(value) { this.value = value; }
  map(fn) { return this; }
  flatMap(fn) { return this; }
  fold(leftFn, rightFn) { return leftFn(this.value); }
  swap() { return new Right(this.value); }
  getOr(defaultValue) { return defaultValue; }
}

class Right {
  constructor(value) { this.value = value; }
  map(fn) { return new Right(fn(this.value)); }
  flatMap(fn) { return fn(this.value); }
  fold(leftFn, rightFn) { return rightFn(this.value); }
  swap() { return new Left(this.value); }
  getOr() { return this.value; }
}

const either = { left: v => new Left(v), right: v => new Right(v) };

// 使用
const validateAge = (age) =>
  age < 0 ? either.left("Negative age") :
  age > 150 ? either.left("Too old") :
  either.right(age);

const validateEmail = (email) =>
  email.includes('@') ? either.right(email) : either.left("Invalid email");

const result = validateEmail("alice@example.com")
  .flatMap(email => validateAge(30).map(age => ({ email, age })));

result.fold(
  error => console.log("Error:", error),
  user => console.log("Valid:", user)
);

data Validation a b = Failure a | Success b

instance Semigroup a => Applicative (Validation a) where
  pure = Success
  Failure e1 <*> Failure e2 = Failure (e1 <> e2)  -- 收集所有错误
  Failure e1 <*> Success _  = Failure e1
  Success _  <*> Failure e2 = Failure e2
  Success f  <*> Success x  = Success (f x)

-- 使用
data User = User { name :: String, email :: String, age :: Int }

validateUser :: String -> String -> Int -> Validation [String] User
validateUser name email age =
  User <$> validateName name <*> validateEmail email <*> validateAge age
  where
    validateName n
      | null n    = Failure ["Name required"]
      | otherwise = Success n
    validateEmail e
      | '@' `elem` e = Success e
      | otherwise    = Failure ["Invalid email"]
    validateAge a
      | a >= 0 && a <= 150 = Success a
      | otherwise          = Failure ["Invalid age"]

-- 结果
validateUser "" "invalid" (-1)
-- Failure ["Name required", "Invalid email", "Invalid age"]

class Validation {
  static success(value) { return new Success(value); }
  static failure(errors) { return new Failure(errors); }
}

class Success {
  constructor(value) { this.value = value; }
  map(fn) { return new Success(fn(this.value)); }
  ap(other) {
    if (other instanceof Failure) return other;
    return new Success(this.value(other.value));
  }
}

class Failure {
  constructor(errors) { this.errors = errors; }
  map(fn) { return this; }
  ap(other) {
    if (other instanceof Failure) return new Failure([...this.errors, ...other.errors]);
    return this;
  }
}

// 使用
const validateUser = (name, email, age) => {
  const validateName = name.length > 0
    ? Validation.success(name)
    : Validation.failure(["Name required"]);

  const validateEmail = email.includes('@')
    ? Validation.success(email)
    : Validation.failure(["Invalid email"]);

  const validateAge = age >= 0 && age <= 150
    ? Validation.success(age)
    : Validation.failure(["Invalid age"]);

  return Validation.success(
    name => email => age => ({ name, email, age })
  ).ap(validateName).ap(validateEmail).ap(validateAge);
};

validateUser("", "invalid", -1);
// Failure(["Name required", "Invalid email", "Invalid age"])

// 组合多个可能失败的操作
const fetchAndProcess = (url) =>
  Task.fromPromise(fetch(url))
    .mapError(err => `Network error: ${err.message}`)
    .flatMap(response =>
      response.ok
        ? Task.fromPromise(response.json())
        : Task.rejected(`HTTP ${response.status}`)
    )
    .map(data => data.items)
    .mapError(err => `Processing error: ${err}`);

// 链式错误处理
fetchAndProcess('/api/data')
  .fork(
    error => console.error(error),
    items => renderItems(items)
  );

-- 使用 EitherT 进行错误恢复
withRetry :: Int -> IO (Either String a) -> IO (Either String a)
withRetry 0 action = action
withRetry n action = do
  result <- action
  case result of
    Right x -> return (Right x)
    Left _  -> withRetry (n - 1) action

-- 错误回退
withFallback :: IO (Either String a) -> IO (Either String a) -> IO (Either String a)
withFallback primary fallback = do
  result <- primary
  case result of
    Right x -> return (Right x)
    Left _  -> fallback

// TypeScript 完整的表单验证
type ValidationErrors = Record<string, string[]>;

interface FormData {
  name: string;
  email: string;
  age: number;
  password: string;
}

const validators: Record<string, (value: any) => Either<string[], any>> = {
  name: (name: string) =>
    name.length >= 2 ? right(name) : left(["Name must be at least 2 characters"]),

  email: (email: string) =>
    /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) ? right(email) : left(["Invalid email"]),

  age: (age: number) =>
    age >= 18 ? right(age) : left(["Must be 18+"]),
};

const validateForm = (data: FormData): Either<ValidationErrors, FormData> => {
  const results = Object.entries(data).map(([key, value]) =>
    validators[key] ? validators[key](value).mapError(errors => [key, errors]) : right(value)
  );

  // 收集所有错误
  const errors = results
    .filter(r => r.isLeft)
    .map(r => r.value);

  if (errors.length > 0) {
    return left(Object.fromEntries(errors));
  }

  return right(data);
};

// Rust：结构化 API 错误处理
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
enum ApiError {
    NotFound { resource: String, id: String },
    Validation { field: String, message: String },
    Unauthorized,
    Internal { message: String },
}

impl ApiError {
    fn status_code(&self) -> u16 {
        match self {
            ApiError::NotFound { .. } => 404,
            ApiError::Validation { .. } => 400,
            ApiError::Unauthorized => 401,
            ApiError::Internal { .. } => 500,
        }
    }

    fn to_response(&self) -> serde_json::Value {
        serde_json::json!({
            "error": self,
            "status": self.status_code()
        })
    }
}

fn get_user(id: &str) -> Result<User, ApiError> {
    db::find_user(id)
        .map_err(|_| ApiError::NotFound {
            resource: "user".into(),
            id: id.into(),
        })
}