(* 最简单的闭包 *)
let make_adder n =
  fun x -> x + n    (* n 被捕获到闭包中 *)

let add5 = make_adder 5
let add10 = make_adder 10

let () =
  Printf.printf "add5(3) = %d\n" (add5 3);    (* 8 *)
  Printf.printf "add10(3) = %d\n" (add10 3)   (* 13 *)

let make_counter () =
  let count = ref 0 in
  fun () ->
    incr count;
    !count

let () =
  let counter1 = make_counter () in
  let counter2 = make_counter () in
  Printf.printf "Counter1: %d\n" (counter1 ());  (* 1 *)
  Printf.printf "Counter1: %d\n" (counter1 ());  (* 2 *)
  Printf.printf "Counter2: %d\n" (counter2 ());  (* 1 -- 独立的闭包 *)
  Printf.printf "Counter1: %d\n" (counter1 ())   (* 3 *)

let x = 10

let f () =
  let x = 20 in
  fun () -> x   (* 捕获的是外层的 x = 20，不是全局的 x = 10 *)

let () =
  let g = f () in
  Printf.printf "g() = %d\n" (g ())   (* 20 *)

let scope = "global"

let outer () =
  let scope = "outer" in
  fun () -> scope   (* 词法作用域：返回 "outer" *)

let () =
  let inner = outer () in
  Printf.printf "scope: %s\n" (inner ())
  (* 词法作用域输出: "outer" *)
  (* 动态作用域会输出: "global" -- 但 OCaml 不是动态作用域 *)

(* 柯里化函数（OCaml 默认） *)
let add x y = x + y
(* 类型: int -> int -> int *)
(* 实际上是: int -> (int -> int) *)

(* 非柯里化函数（接受元组参数） *)
let add_uncurried (x, y) = x + y
(* 类型: int * int -> int *)

let () =
  (* 柯里化：可以部分应用 *)
  let add5 = add 5 in
  Printf.printf "add5(3) = %d\n" (add5 3);

  (* 非柯里化：必须一次提供所有参数 *)
  Printf.printf "add(3,4) = %d\n" (add_uncurried (3, 4))

(* 柯里化等价转换 *)
(* add 的定义等价于： *)
let add_explicit =
  fun x -> (fun y -> x + y)

(* 列表操作的部分应用 *)
let double_each = List.map (fun x -> x * 2)
let filter_positives = List.filter (fun x -> x > 0)
let sum = List.fold_left (+) 0

let () =
  let data = [-1; 2; -3; 4; 5; -6] in
  let result =
    data
    |> filter_positives    (* [2; 4; 5] *)
    |> double_each         (* [4; 8; 10] *)
    |> sum                 (* 22 *)
  in
  Printf.printf "Result: %d\n" result

(* printf 的部分应用 *)
let debug = Printf.printf "[DEBUG] %s\n"
let error = Printf.printf "[ERROR] %s\n"

let () =
  debug "Application started";
  error "Connection failed";
  debug "Retrying..."

(* 创建一个格式化日期的函数 *)
let format_date sep year month day =
  Printf.sprintf "%d%s%02d%s%02d" year sep month sep day

(* 部分应用产生特定格式 *)
let format_iso = format_date "-"      (* 2026-05-11 *)
let format_us = format_date "/"       (* 2026/05/11 *)
let format_compact = format_date ""   (* 20260511 *)

let () =
  Printf.printf "ISO: %s\n" (format_iso 2026 5 11);
  Printf.printf "US: %s\n" (format_us 2026 5 11);
  Printf.printf "Compact: %s\n" (format_compact 2026 5 11)

let with_retry ~max_retries ~on_error f =
  let rec attempt n =
    try f () with
    | exn ->
      if n >= max_retries then begin
        on_error exn n;
        raise exn
      end else begin
        Printf.printf "Retry %d/%d...\n" (n + 1) max_retries;
        attempt (n + 1)
      end
  in
  attempt 0

let () =
  let counter = ref 0 in
  let result = with_retry
    ~max_retries:3
    ~on_error:(fun exn n ->
      Printf.printf "Failed after %d retries: %s\n"
        n (Printexc.to_string exn))
    (fun () ->
      incr counter;
      if !counter < 3 then
        failwith "temporary failure"
      else
        "success")
  in
  Printf.printf "Result: %s\n" result

(* 闭包捕获整个环境——可能不是你想要的 *)
let bad_example data =
  let total = List.fold_left (+) 0 data in
  fun x ->
    (* 这个闭包捕获了 data 和 total *)
    (* 即使只用了 total，data 也不会被 GC 回收 *)
    x + total

(* 好的做法：只捕获需要的值 *)
let good_example data =
  let total = List.fold_left (+) 0 data in
  let _ignore = data in  (* 允许 GC 回收 data *)
  fun x -> x + total

(* 更好的做法 *)
let best_example data =
  let total = List.fold_left (+) 0 data in
  (* total 是 int，直接复制到闭包中 *)
  fun x -> x + total

let curry f x y = f (x, y)
let uncurry f (x, y) = f x y

(* 使用示例 *)
let add_curried x y = x + y
let add_uncurried = uncurry add_curried

let pair_apply f (x, y) = (f x, f y)

let () =
  Printf.printf "curry: %d\n" (add_curried 3 4);
  Printf.printf "uncurry: %d\n" (add_uncurried (3, 4));

  let (a, b) = pair_apply (fun x -> x * 2) (3, 4) in
  Printf.printf "pair_apply: (%d, %d)\n" a b

type request = {
  path : string;
  headers : (string * string) list;
  body : string;
}

type response = {
  status : int;
  body : string;
}

type middleware = request -> (request -> response) -> response

(* 日志中间件 *)
let logging_middleware : middleware = fun req next ->
  Printf.printf "[LOG] %s %s\n" "GET" req.path;
  let resp = next req in
  Printf.printf "[LOG] Response: %d\n" resp.status;
  resp

(* 认证中间件 *)
let auth_middleware : middleware = fun req next ->
  let has_token = List.exists
    (fun (k, _) -> k = "Authorization") req.headers in
  if has_token then
    next req
  else
    { status = 401; body = "Unauthorized" }

(* CORS 中间件 *)
let cors_middleware : middleware = fun req next ->
  let resp = next req in
  { resp with
    body = resp.body
  }

(* 组合中间件 *)
let compose_middlewares middlewares handler =
  List.fold_right
    (fun mw acc -> fun req -> mw req acc)
    middlewares
    handler

(* 最终处理器 *)
let final_handler : request -> response = fun req ->
  { status = 200; body = Printf.sprintf "Hello from %s" req.path }

let () =
  let app = compose_middlewares
    [logging_middleware; auth_middleware; cors_middleware]
    final_handler
  in

  let req1 = {
    path = "/api/users";
    headers = [("Authorization", "Bearer token123")];
    body = "";
  } in
  let resp1 = app req1 in
  Printf.printf "Status: %d, Body: %s\n" resp1.status resp1.body;

  let req2 = {
    path = "/api/users";
    headers = [];
    body = "";
  } in
  let resp2 = app req2 in
  Printf.printf "Status: %d, Body: %s\n" resp2.status resp2.body