-- 编译器可以推断出所有类型
id x = x            -- id :: a -> a
const x y = x       -- const :: a -> b -> a
add x y = x + y     -- add :: Num a => a -> a -> a

-- 类型推断过程
-- x = 5         → x :: Int（从字面量推断）
-- y = x + 1     → y :: Int（从 x + 1 推断）
-- f = \x -> x+1 → f :: Int -> Int

-- 推断算法（简化版）
-- 1. 给每个表达式分配类型变量 (a, b, c, ...)
-- 2. 收集约束（unification constraints）
-- 3. 统一求解（unification）
-- 4. 泛化（generalization）→ 多态类型

let x = 5;           // x: i32
let y = x + 1;       // y: i32
let z = vec![1, 2];  // z: Vec<i32>

// 闭包类型推断
let add = |a, b| a + b;  // add: impl Fn(i32, i32) -> i32

// 泛型函数类型推断
fn identity<T>(x: T) -> T { x }
let val = identity(42);  // val: i32

-- 参数多态：类型参数
identity :: a -> a
identity x = x

-- 可以用于任何类型
identity 42          :: Int
identity "hello"     :: String
identity [1, 2, 3]   :: [Int]

-- 多参数多态
const :: a -> b -> a
const x y = x

compose :: (b -> c) -> (a -> b) -> a -> c
compose f g x = f (g x)

-- 自然变换（Natural Transformation）：不关心具体类型
-- ∀ f. Functor f => f a -> f a

// 泛型函数
function identity<T>(x: T): T {
  return x;
}

identity(42);       // 推断为 number
identity("hello");  // 推断为 string

// 约束泛型
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

// 条件类型
type IsString<T> = T extends string ? true : false;

-- 定义类型类
class Printable a where
  toString :: a -> String

-- 为类型实现实例
instance Printable Int where
  toString = show

instance Printable Bool where
  toString True  = "Yes"
  toString False = "No"

instance Printable a => Printable [a] where
  toString xs = "[" ++ intercalate ", " (map toString xs) ++ "]"

-- 使用
printValue :: Printable a => a -> IO ()
printValue x = putStrLn (toString x)

-- 常见类型类
-- Eq      (==)  相等比较
-- Ord     compare 排序
-- Show    show  转字符串
-- Read    read  字符串转类型
-- Num     (+), (*), abs 数值运算
-- Functor fmap  函子
-- Monad   >>=   单子

-- 类型构造器
data Maybe a = Nothing | Just a
-- Maybe :: * -> *   （接受一个类型参数）

data Either a b = Left a | Right b
-- Either :: * -> * -> *   （接受两个类型参数）

data Pair a b = Pair a b
-- Pair :: * -> * -> *

-- 高阶类型
data Fix f = Fix (f (Fix f))
-- Fix :: (* -> *) -> *

-- 类型族（Type Families）
type family Element a where
  Element [a]    = a
  Element (Set a) = a
  Element (Map k v) = (k, v)

-- GADTs（广义代数数据类型）
data Expr a where
  LitI  :: Int -> Expr Int
  LitB  :: Bool -> Expr Bool
  Add   :: Expr Int -> Expr Int -> Expr Int
  If    :: Expr Bool -> Expr a -> Expr a -> Expr a

eval :: Expr a -> a
eval (LitI n)    = n
eval (LitB b)    = b
eval (Add a b)   = eval a + eval b
eval (If c t e)  = if eval c then eval t else eval e

-- Kind 表示法
Int       :: *              -- 具体类型
Maybe     :: * -> *         -- 接受一个类型参数
Either    :: * -> * -> *    -- 接受两个类型参数
Monad     :: (* -> *) -> Constraint  -- 接受一个类型构造器

-- Kind 签名的类型类
class Functor f where
  fmap :: (a -> b) -> f a -> f b
  -- f 的 kind 是 * -> *

class Functor f => Applicative f where
  pure  :: a -> f a
  (<*>) :: f (a -> b) -> f a -> f b

class Applicative m => Monad m where
  (>>=) :: m a -> (a -> m b) -> m b

// TypeScript 模拟 HKT（使用编码技巧）
interface HKT<F, A> {
  _F: F;
  _A: A;
}

// 注册类型
interface HKTMap {
  Maybe: Maybe<any>;
  Array: Array<any>;
}

// 使用
type Apply<F extends keyof HKTMap, A> = HKTMap[F] extends HKT<F, A>
  ? HKT<F, A>
  : never;

trait Functor {
    type Wrapped<A>;

    fn map<A, B, F>(fa: Self::Wrapped<A>, f: F) -> Self::Wrapped<B>
    where
        F: Fn(A) -> B;
}

struct OptionFunctor;

impl Functor for OptionFunctor {
    type Wrapped<A> = Option<A>;

    fn map<A, B, F>(fa: Option<A>, f: F) -> Option<B>
    where
        F: Fn(A) -> B,
    {
        fa.map(f)
    }
}

-- Idris（依赖类型语言）示例
-- 向量长度在类型中编码
data Vect : Nat -> Type -> Type where
  Nil  : Vect 0 a
  (::) : a -> Vect n a -> Vect (S n) a

-- 类型保证长度正确
append : Vect n a -> Vect m a -> Vect (n + m) a
append Nil       ys = ys
append (x :: xs) ys = x :: append xs ys

-- head 不可能对空列表调用（编译时保证）
head : Vect (S n) a -> a
head (x :: _) = x

-- 用 newtype 创建类型安全的别名
newtype UserId = UserId Int
newtype Email = Email String

-- 防止类型混淆
sendEmail :: Email -> Subject -> Body -> IO ()
sendEmail (Email addr) subj body = ...

-- 不能传 UserId 给 sendEmail

// Rust 的 newtype
struct UserId(u64);
struct Email(String);

fn send_email(to: &Email, subject: &str, body: &str) { ... }

// 不能传 UserId 给 send_email

-- 幽灵类型参数不出现在值构造器中
data Validated
data Unvalidated

data User a = User { name :: String, email :: String }

validate :: User Unvalidated -> Maybe (User Validated)
validate (User n e)
  | '@' `elem` e && not (null n) = Just (User n e)
  | otherwise = Nothing

-- 只有验证过的用户才能注册
register :: User Validated -> IO ()
register user = ...

// TypeScript 类型安全的 API 客户端
type ApiResponse<T> =
  | { status: 'success'; data: T }
  | { status: 'error'; message: string };

interface User { id: number; name: string; email: string; }
interface Post { id: number; title: string; body: string; userId: number; }

// 类型安全的 fetch
async function apiGet<T>(url: string): Promise<ApiResponse<T>> {
  try {
    const response = await fetch(url);
    if (!response.ok) return { status: 'error', message: response.statusText };
    const data = await response.json();
    return { status: 'success', data: data as T };
  } catch (err) {
    return { status: 'error', message: String(err) };
  }
}

// 使用（类型安全）
const userResult = await apiGet<User>('/api/users/1');
const postResult = await apiGet<Post[]>('/api/posts');

// 处理结果
if (userResult.status === 'success') {
  console.log(userResult.data.name);  // 类型安全
}