-- Haskell 中函数天然是一等公民
f :: Int -> Int
f = \x -> x + 1

-- 函数列表
funcs :: [Int -> Int]
funcs = [(+1), (*2), (^2)]

-- 应用函数列表
result :: [Int]
result = map ($ 5) funcs  -- [6, 10, 25]

// 赋值给变量
const double = (x) => x * 2;

// 作为参数
const apply = (fn, x) => fn(x);
apply(double, 5);  // 10

// 作为返回值
const multiply = (a) => (b) => a * b;
const triple = multiply(3);
triple(10);  // 30

// 存储在数据结构中
const operations = {
  add: (a, b) => a + b,
  sub: (a, b) => a - b,
  mul: (a, b) => a * b,
};
operations.add(2, 3);  // 5

# 赋值给变量
double = lambda x: x * 2

# 作为参数
def apply(fn, x):
    return fn(x)

apply(double, 5)  # 10

# 作为返回值
def multiply(a):
    return lambda b: a * b

triple = multiply(3)
triple(10)  # 30

# 存储在数据结构中
operations = {
    'add': lambda a, b: a + b,
    'sub': lambda a, b: a - b,
    'mul': lambda a, b: a * b,
}
operations['add'](2, 3)  # 5

// 赋值给变量
let double = |x: i32| x * 2;

// 作为参数
fn apply<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(x)
}

apply(double, 5);  // 10

// 作为返回值（闭包）
fn multiply(a: i32) -> impl Fn(i32) -> i32 {
    move |b| a * b
}

let triple = multiply(3);
triple(10);  // 30

// 存储在 HashMap 中
use std::collections::HashMap;
let mut ops: HashMap<&str, Box<dyn Fn(i32, i32) -> i32>> = HashMap::new();
ops.insert("add", Box::new(|a, b| a + b));

;; 赋值给变量
(def double (fn [x] (* x 2)))

;; 作为参数
(defn apply-fn [f x] (f x))
(apply-fn double 5)  ;; 10

;; 作为返回值
(defn multiply [a]
  (fn [b] (* a b)))

(def triple (multiply 3))
(triple 10)  ;; 30

;; 存储在 map 中
(def operations
  {:add (fn [a b] (+ a b))
   :sub (fn [a b] (- a b))
   :mul (fn [a b] (* a b))})
((:add operations) 2 3)  ;; 5

// retry：重试函数
const retry = (fn, maxAttempts = 3) => async (...args) => {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn(...args);
    } catch (err) {
      if (attempt === maxAttempts) throw err;
      await new Promise(r => setTimeout(r, 2 ** attempt * 100));
    }
  }
};

// once：只执行一次
const once = (fn) => {
  let called = false;
  let result;
  return (...args) => {
    if (!called) {
      called = true;
      result = fn(...args);
    }
    return result;
  };
};

// tap：调试用，不改变值
const tap = (fn) => (x) => {
  fn(x);
  return x;
};

// 使用示例
const result = [1, 2, 3, 4, 5]
  .map(x => x * 2)
  .filter(x => x > 4)
  .reduce((sum, x) => sum + x, 0);
// result = 24

-- retry
retry :: Int -> IO a -> IO a
retry 0 action = action
retry n action = action `catch` \(_ :: SomeException) -> retry (n-1) action

-- once（使用 IORef）
once :: IO a -> IO (IO a)
once action = do
  ref <- newIORef Nothing
  return $ do
    cached <- readIORef ref
    case cached of
      Just val -> return val
      Nothing  -> do
        val <- action
        writeIORef ref (Just val)
        return val

-- tap
tap :: (a -> IO ()) -> a -> IO a
tap f x = f x >> return x

-- 使用 . 运算符
-- f . g = \x -> f (g x)
-- 从右到左组合

addOne :: Int -> Int
addOne = (+1)

double :: Int -> Int
double = (*2)

-- doubleAfterAddOne = double . addOne
-- doubleAfterAddOne x = double (addOne x)
doubleAfterAddOne :: Int -> Int
doubleAfterAddOne = double . addOne

-- doubleAfterAddOne 3 == 8  (3+1=4, 4*2=8)

-- 多函数组合
pipeline :: String -> String
pipeline = unwords . map (take 10) . words . map toLower

// 手动组合
const compose = (...fns) =>
  (x) => fns.reduceRight((acc, fn) => fn(acc), x);

// 管道（从左到右）
const pipe = (...fns) =>
  (x) => fns.reduce((acc, fn) => fn(acc), x);

// 使用
const addOne = (x) => x + 1;
const double = (x) => x * 2;
const toString = (x) => x.toString();

const doubleAfterAddOne = compose(double, addOne);
doubleAfterAddOne(3);  // 8

const pipeline = pipe(addOne, double, toString);
pipeline(3);  // "8"

// Ramda 库
const R = require('ramda');
const transform = R.pipe(
  R.map(R.prop('name')),
  R.filter(name => name.length > 3),
  R.sortBy(R.identity),
  R.join(', ')
);

from functools import reduce

# 手动组合
def compose(*fns):
    return lambda x: reduce(lambda acc, fn: fn(acc), reversed(fns), x)

# 管道
def pipe(*fns):
    return lambda x: reduce(lambda acc, fn: fn(acc), fns, x)

add_one = lambda x: x + 1
double = lambda x: x * 2
to_str = lambda x: str(x)

double_after_add_one = compose(double, add_one)
double_after_add_one(3)  # 8

pipeline = pipe(add_one, double, to_str)
pipeline(3)  # "8"

# toolz 库
from toolz import pipe, compose
from toolz.curried import map, filter, pipe

// Rust 没有内置组合，但可以用函数式方法链
let result: i32 = (1..=5)
    .map(|x| x + 1)
    .filter(|x| x > &3)
    .sum();

// 或使用自定义组合宏
macro_rules! compose {
    ($f:expr) => { $f };
    ($f:expr, $($rest:expr),+) => {
        move |x| compose!($($rest),+)( $f(x) )
    };
}

fn add_one(x: i32) -> i32 { x + 1 }
fn double(x: i32) -> i32 { x * 2 }

let f = compose!(add_one, double);
f(3)  // (3*2)+1 = 7

;; 使用 comp（从右到左）
(def double-after-add-one (comp #(* 2 %) #(+ 1 %)))
(double-after-add-one 3)  ;; 8

;; 使用 -> 和 ->> 宏（从左到右）
(-> 3
    (+ 1)      ;; 4
    (* 2)      ;; 8
    str)       ;; "8"

;; 管道操作
(->> [1 2 3 4 5]
     (map #(* 2 %))      ;; (2 4 6 8 10)
     (filter #(> % 4))   ;; (6 8 10)
     (reduce +))          ;; 24

-- 结合律验证
-- (f . g) . h = f . (g . h)

-- 单位元
id :: a -> a
id x = x

-- id . f = f
-- f . id = f

-- Haskell 中函数天然柯里化
add :: Int -> Int -> Int
add x y = x + y

-- 等价于
-- add :: Int -> (Int -> Int)
-- add = \x -> \y -> x + y

add3 :: Int -> Int
add3 = add 3      -- 部分应用

add3 5            -- 8
add3 10           -- 13

-- map 也是柯里化的
map :: (a -> b) -> [a] -> [b]

-- 部分应用 map
doubleAll :: [Int] -> [Int]
doubleAll = map (*2)

// 手动柯里化
const curry = (fn) => {
  const arity = fn.length;
  const curried = (...args) =>
    args.length >= arity
      ? fn(...args)
      : (...moreArgs) => curried(...args, ...moreArgs);
  return curried;
};

// 使用
const add = curry((a, b) => a + b);
const add3 = add(3);
add3(5);   // 8
add3(10);  // 13

// 多参数柯里化
const sum3 = curry((a, b, c) => a + b + c);
sum3(1)(2)(3);    // 6
sum3(1, 2)(3);    // 6
sum3(1)(2, 3);    // 6
sum3(1, 2, 3);    // 6

// Ramda 自动柯里化
const R = require('ramda');
const multiply = R.multiply(3);
multiply(10);  // 30

from functools import partial

# 使用 partial（偏应用）
def add(a, b):
    return a + b

add3 = partial(add, 3)
add3(5)   # 8
add3(10)  # 13

# 手动柯里化装饰器
def curry(fn):
    import inspect
    arity = len(inspect.signature(fn).parameters)

    def curried(*args):
        if len(args) >= arity:
            return fn(*args)
        return lambda *more: curried(*args, *more)

    return curried

@curry
def sum3(a, b, c):
    return a + b + c

sum3(1)(2)(3)    # 6
sum3(1, 2)(3)    # 6

// Rust 不原生支持柯里化，但可以手动实现
fn add(a: i32) -> impl Fn(i32) -> i32 {
    move |b| a + b
}

let add3 = add(3);
add3(5);   // 8
add3(10);  // 13

// 宏实现柯里化
macro_rules! curry {
    ($name:ident, $first:ident : $fty:ty, $($rest:ident : $rty:ty),* -> $ret:ty, $body:expr) => {
        fn $name($first: $fty) -> impl Fn($($rty),*) -> $ret {
            move |$($rest),*| $body
        }
    };
}

;; Clojure 不自动柯里化，但可以手动实现
(defn curry2 [f]
  (fn [a]
    (fn [b]
      (f a b))))

(def add (curry2 +))
((add 3) 5)  ;; 8

;; 更实用的方式：使用 partial
(def add3 (partial + 3))
(add3 5)   ;; 8
(add3 10)  ;; 13

;; partial 可以部分应用任意数量参数
(def add-1-2 (partial + 1 2))
(add-1-2 3)  ;; 6

// 日志函数的偏应用
const log = (level, timestamp, component, message) =>
  `[${timestamp}] [${level}] [${component}] ${message}`;

// 固定级别和组件
const infoLog = (component) => (message) =>
  log('INFO', new Date().toISOString(), component, message);

const authLog = infoLog('AuthService');
authLog('User logged in');   // [2026-01-01T...] [INFO] [AuthService] User logged in

// 事件处理偏应用
const handleEvent = (eventType, handler) => (event) => {
  if (event.type === eventType) handler(event);
};

const handleClick = handleEvent('click', (e) => {
  console.log('Clicked at', e.clientX, e.clientY);
});

document.addEventListener('click', handleClick);

from functools import partial

# HTTP 客户端的偏应用
def http_request(method, base_url, path, headers=None):
    url = f"{base_url}{path}"
    headers = headers or {}
    return {'method': method, 'url': url, 'headers': headers}

# 创建专用请求函数
api_request = partial(http_request, 'GET', 'https://api.example.com')
get_users = partial(api_request, '/users')
get_user = lambda uid: partial(api_request, f'/users/{uid}')()

get_users()         # {'method': 'GET', 'url': 'https://api.example.com/users', ...}
get_user(42)        # {'method': 'GET', 'url': 'https://api.example.com/users/42', ...}

// 数据处理管道
const pipeline = (...steps) => (input) =>
  steps.reduce((data, step) => step(data), input);

// 用户注册处理管道
const processRegistration = pipeline(
  validateInput,
  normalizeEmail,
  checkDuplicate,
  hashPassword,
  createUserRecord,
  sendWelcomeEmail
);

const result = await processRegistration({
  email: ' Alice@Example.COM ',
  password: 'secret123',
  name: 'Alice'
});

// 组合子：通过组合产生新行为的函数

// identity
const I = (x) => x;

// constant
const K = (x) => (_y) => x;

// substitution
const S = (f) => (g) => (x) => f(x)(g(x));

// flip
const flip = (f) => (a) => (b) => f(b)(a);

// on
const on = (f) => (g) => (a) => (b) => f(g(a))(g(b));

// 使用：按长度比较字符串
const compareByLength = on((a) => (b) => a - b)(s => s.length);
compareByLength('abc')('de');  // 1 (3 - 2 = 1)

-- 有点（显式参数）
isEven :: Int -> Bool
isEven x = x `mod` 2 == 0

-- 无点（Point-free）
isEven :: Int -> Bool
isEven = (== 0) . (`mod` 2)

-- 有点
sumOfSquares :: [Int] -> Int
sumOfSquares xs = sum (map (^2) xs)

-- 无点
sumOfSquares :: [Int] -> Int
sumOfSquares = sum . map (^2)

// JavaScript 中的 point-free
// 有点
const getActiveUserNames = (users) =>
  users.filter(u => u.active).map(u => u.name);

// 无点（使用 Ramda）
const getActiveUserNames = R.pipe(
  R.filter(R.prop('active')),
  R.map(R.prop('name'))
);

// Express/Koa 风格的中间件（函数组合的典型应用）
const compose = (...middlewares) =>
  (context) => {
    let index = -1;
    const dispatch = (i) => {
      if (i <= index) return Promise.reject(new Error('next() called multiple times'));
      index = i;
      const fn = middlewares[i];
      if (!fn) return Promise.resolve();
      return Promise.resolve(fn(context, () => dispatch(i + 1)));
    };
    return dispatch(0);
  };

// 纯函数中间件
const logging = async (ctx, next) => {
  console.log(`[${ctx.method}] ${ctx.path}`);
  await next();
};

const auth = async (ctx, next) => {
  if (!ctx.headers.authorization) throw new Error('Unauthorized');
  ctx.user = decodeToken(ctx.headers.authorization);
  await next();
};

const cors = async (ctx, next) => {
  ctx.headers['Access-Control-Allow-Origin'] = '*';
  await next();
};

const app = compose(cors, logging, auth);

# ETL 管道使用函数组合
from functools import reduce
from datetime import datetime

def compose(*fns):
    return lambda x: reduce(lambda acc, fn: fn(acc), fns, x)

# 各步骤都是纯函数
def parse_csv(raw_data):
    return [line.split(',') for line in raw_data.strip().split('\n')]

def skip_header(rows):
    return rows[1:]

def parse_dates(rows, date_col=2):
    return [
        [*row[:date_col], datetime.strptime(row[date_col], '%Y-%m-%d'), *row[date_col+1:]]
        for row in rows
    ]

def filter_valid(rows):
    return [row for row in rows if row[3] > 0]  # amount > 0

def summarize(rows):
    from collections import defaultdict
    summary = defaultdict(float)
    for row in rows:
        summary[row[1]] += float(row[3])
    return dict(summary)

# 组合管道
process_data = compose(
    parse_csv,
    skip_header,
    lambda rows: parse_dates(rows),
    filter_valid,
    summarize
)

result = process_data(raw_csv_data)