函数式模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
-- 计算两个数的平方和
squareSum1 :: Int -> Int -> Int
squareSum1 x y = (x * x) + (y * y)

-- let表达式
squareSum2 :: Int -> Int -> Int
squareSum2 x y = 
  let a = x * x   -- 无副作用表达式
      b = y * y   -- 无副作用表达式
  in a + b        -- 返回结果

-- 无谓的堆叠表达式🤷
squareSum3 :: Int -> Int -> Int
squareSum3 x y = 
  x * x  -- 这个表达式无副作用, 但结果未被返回
  y * y  -- 这个表达式无副作用, 也未被返回
  (x * x) + (y * y)  -- 只有这个表达式的结果被返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
from functools import reduce
from itertools import takewhile, dropwhile
from collections import defaultdict
from toolz import compose, memoize, groupby

# map: 对列表中的每个元素执行平方操作
mapped = list(map(lambda x: x**2, [1, 2, 3]))  # [1, 4, 9]

# filter: 筛选出列表中所有偶数
filtered = list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4]))  # [2, 4]

# reduce: 将列表元素累加起来, 初始值为0
reduced = reduce(lambda acc, x: acc + x, [1, 2, 3], 0)  # 6

# foldl(左折叠): 等价于reduce, 从左到右累加
foldl_total = reduce(lambda acc, x: acc + x, [1, 2, 3], 0)  # 6

# sort: 对列表进行排序
sorted_list = sorted([2, 3, 1, 4])  # [1, 2, 3, 4]

# forEach: 遍历列表并打印每个元素
for x in [1, 2, 3]:
    print(x)

# flatmap: 先映射再扁平化, 合并嵌套列表
lists = [[1, 2], [3, 4]]
flat = [item for sublist in lists for item in sublist]  # [1, 2, 3, 4]

# zipWith: 对应位置元素相加
pairs = [a + b for a, b in zip([1, 2, 3], [4, 5, 6])]  # [5, 7, 9]

# compose: 函数组合, 先执行div3, 再执行mul10, 最后执行add5
add5 = lambda x: x + 5
mul10 = lambda x: x * 10
div3 = lambda x: x / 3
calculate = compose(add5, mul10, div3)
result = calculate(3)  # 计算结果为15

# takeWhile: 从列表开头取出满足条件的元素
taken = list(takewhile(lambda x: x < 3, [1, 2, 3, 4]))  # [1, 2]

# dropWhile: 丢弃开头满足条件的元素, 返回剩余部分
dropped = list(dropwhile(lambda x: x < 3, [1, 2, 3, 4]))  # [3, 4]

# groupBy: 根据字符串长度分组
words = ["cat", "apple", "cherry", "dog"]
grouped = groupby(len, words)  
# 结果为 {3: ['cat', 'dog'], 5: ['apple'], 6: ['cherry']}

# memoize: 对递归函数进行缓存, 避免重复计算
@memoize
def factorial(x):
    if x <= 1:
        return 1
    return x * factorial(x - 1)

factorial_with_memo = factorial
factorial_with_memo(1000)  # 第一次计算较慢
factorial_with_memo(1000)  # 第二次调用瞬间返回, 速度极快

data Tree a = Nil | Leaf a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Maybe {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Maybe(value);
  }

  static nothing() {
    return new Maybe(null);
  }

  // map用来接收 "直接修改monad中值"的函数
  map(fn) {
    return this.value === null ? Maybe.nothing() : Maybe.of(fn(this.value));
  }

  // flatMap用来接收 "通过monad中的值算出另一个monad"的函数
  flatMap(fn) {
    return this.value === null ? Maybe.nothing() : fn(this.value);
  }

  isNothing() {
    return this.value === null;
  }
}

Maybe.of(42);                 // Maybe { value: 42 }
Maybe.of(5).map(x => x * 2);  // Maybe { value: 10 }
Maybe.of(5).flatMap(x => Maybe.of(x * 2));  // Maybe { value: 10 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 不使用monad时, 代码冗长混乱
function getUserEmail(userId) {
  const user = getUser(userId);
  if (user === null) return null;
  const profile = getProfile(user.profileId);
  if (profile === null) return null;
  return profile.email;
}

// 使用monad之后, 代码十分清晰, 异常处理由monad负责
function getUserEmailSafe(userId) {
  return Maybe.of(userId)
    .flatMap(id => Maybe.of(getUser(id)))
    .flatMap(user => Maybe.of(getProfile(user?.profileId)))
    .map(profile => profile?.email);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class Either {
  constructor(value, isLeft = false) {
    this.value = value;
    this.isLeft = isLeft;
  }

  static right(value) {
    return new Either(value, false);
  }

  static left(value) {
    return new Either(value, true);
  }

  map(fn) {
    return this.isLeft ? this : Either.right(fn(this.value));
  }

  flatMap(fn) {
    return this.isLeft ? this : fn(this.value);
  }

  fold(leftFn, rightFn) {
    return this.isLeft ? leftFn(this.value) : rightFn(this.value);
  }
}

// Usage example
function divide(a, b) {
  return b === 0 ? Either.left("Division by zero") : Either.right(a / b);
}

function sqrt(x) {
  return x < 0 ? Either.left("Negative square root") : Either.right(Math.sqrt(x));
}

// Chaining operations
const result = Either.right(16)
  .flatMap(x => divide(x, 4))  // Right(4)
  .flatMap(x => sqrt(x))       // Right(2)
  .fold(
    error => `Error: ${error}`,
    value => `Success: ${value}`
  );

console.log(result); // "Success: 2"