-- Lambda 演算: λx. x + 1
\x -> x + 1

-- 命名函数
addOne x = x + 1

// Lambda 演算: λx. x + 1
const addOne = x => x + 1;

// 等价的匿名函数
const addOneAnon = function(x) { return x + 1; };

# Lambda 演算: λx. x + 1
add_one = lambda x: x + 1

# 等价的命名函数
def add_one(x):
    return x + 1

// Lambda 演算: λx. x + 1
let add_one = |x: i32| x + 1;

// 函数指针
fn add_one_fn(x: i32) -> i32 {
    x + 1
}

;; Lambda 演算: λx. x + 1
(fn [x] (+ x 1))

;; 简写
#(+ % 1)

-- Church 编码：用函数表示自然数
-- 0 = λf. λx. x
-- 1 = λf. λx. f x
-- 2 = λf. λx. f (f x)

type Church = (a -> a) -> a -> a

churchZero :: Church
churchZero = \f x -> x

churchSucc :: Church -> Church
churchSucc n = \f x -> f (n f x)

churchToInt :: Church -> Int
churchToInt n = n (+1) 0

-- 2 的 Church 编码
two :: Church
two = \f x -> f (f x)

-- 加法
churchAdd :: Church -> Church -> Church
churchAdd m n = \f x -> m f (n f x)

// 计算偶数的平方和
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let result = 0;
for (let i = 0; i < numbers.length; i++) {
  if (numbers[i] % 2 === 0) {
    result += numbers[i] * numbers[i];
  }
}
// result = 220

// 同样的计算，函数式风格
const result = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  .filter(n => n % 2 === 0)
  .map(n => n * n)
  .reduce((sum, n) => sum + n, 0);
// result = 220

import qualified Data.Map as Map
import Data.Char (toLower)

wordCount :: String -> Map.Map String Int
wordCount = foldl (\acc word -> Map.insertWith (+) word 1 acc) Map.empty
          . words
          . map toLower

-- wordCount "hello world hello" == Map.fromList [("hello",2),("world",1)]

const wordCount = text =>
  text.toLowerCase().split(/\s+/).reduce((counts, word) => {
    counts[word] = (counts[word] || 0) + 1;
    return counts;
  }, {});

from collections import Counter
from functools import reduce

def word_count(text):
    return Counter(text.lower().split())

# 或者纯函数式版本
def word_count_fp(text):
    words = text.lower().split()
    return reduce(
        lambda acc, w: {**acc, w: acc.get(w, 0) + 1},
        words,
        {}
    )

use std::collections::HashMap;

fn word_count(text: &str) -> HashMap<String, usize> {
    text.to_lowercase()
        .split_whitespace()
        .fold(HashMap::new(), |mut acc, word| {
            *acc.entry(word.to_string()).or_insert(0) += 1;
            acc
        })
}

(defn word-count [text]
  (->> (clojure.string/split (clojure.string/lower-case text) #"\s+")
       (frequencies)))

;; (word-count "hello world hello")
;; => {"hello" 2, "world" 1}

class BankAccount {
  constructor(balance) {
    this.balance = balance;  // 可变状态
  }
  deposit(amount) {
    this.balance += amount;  // 修改内部状态
    return this;
  }
  withdraw(amount) {
    if (amount > this.balance) throw new Error('Insufficient funds');
    this.balance -= amount;
    return this;
  }
}

const BankAccount = (balance) => ({
  balance,
  deposit: (amount) => BankAccount(balance + amount),      // 返回新对象
  withdraw: (amount) => {
    if (amount > balance) throw new Error('Insufficient funds');
    return BankAccount(balance - amount);
  }
});

// 函数式风格的订单处理管道
const processOrder = order =>
  validateOrder(order)
    .then(applyDiscount)
    .then(calculateTax)
    .then(reserveInventory)
    .then(createPayment)
    .then(sendConfirmation);

// 每一步都是纯函数，易于测试和组合
const validateOrder = order =>
  order.items.length > 0
    ? Right(order)
    : Left('Order must have at least one item');

const applyDiscount = order =>
  Right({
    ...order,
    total: order.total * (1 - getDiscountRate(order.customer))
  });

# 安装 GHCup（Haskell 工具链管理器）
curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
ghcup install ghc 9.6.3
ghcup install cabal 3.10.2.0
ghcup install stack 2.13.1

# 推荐使用 nvm 管理 Node 版本
nvm install --lts
npm install -g ramda lodash

# 推荐使用 pyenv
pyenv install 3.12.0
pip install toolz cytoolz pyrsistent

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo new fp-exercises

# 安装 Clojure CLI
curl -L -O https://github.com/clojure/brew-install/releases/latest/download/posix-install.sh
chmod +x posix-install.sh
sudo ./posix-install.sh