JavaScript 函数式编程术语大全

向右看齐 2022-05-26 07:17 315阅读 0赞

函数式编程(FP)有许多优点，它也越来越流行了。然而，每个编程范式都有自己独特的术语，函数式编程也不例外。通过提供的这张术语表，希望使你学习函数式编程变得容易些。

示例以 JavaScript (ES2015) 方式呈现。 [Why JavaScript?][Why JavaScript]

在适用的情况下，本文档使用的术语定义在 [Fantasy Land spec][] 中

*  [参数个数 Arity][Arity]
 *  [高阶组件 Higher-Order Functions (HOF)][Higher-Order Functions _HOF]
 *  [偏应用函数 Partial Application][Partial Application]
 *  [柯里化 Currying][Currying]
 *  [闭包 Closure][Closure]
 *  [自动柯里化 Auto Currying][Auto Currying]
 *  [函数合成 Function Composition][Function Composition]
 *  [Continuation][]
 *  [纯函数 Purity][Purity]
 *  [副作用 Side effects][Side effects]
 *  [幂等 Idempotent][Idempotent]
 *  [Point-Free Style][]
 *  [断言 Predicate][Predicate]
 *  [约定 Contracts][Contracts]
 *  [范畴 Category][Category]
 *  [值 Value][Value]
 *  [常量 Constant][Constant]
 *  [函子 Functor][Functor]
 *  [Pointed Functor][]
 *  [提升 Lift][Lift]
 *  [引用透明性 Referential Transparency][Referential Transparency]
 *  [等式推理 Equational Reasoning][Equational Reasoning]
 *  [Lambda][]
 *  [λ演算 Lambda Calculus][Lambda Calculus]
 *  [惰性求值 Lazy evaluation][Lazy evaluation]
 *  [Monoid][]
 *  [Monad][]
 *  [Comonad][]
 *  [Applicative Functor][]
 *  [态射 Morphism][Morphism]
    
     *  [自同态 Endomorphism][Endomorphism]
     *  [同构 Isomorphism][Isomorphism]
 *  [Setoid][]
 *  [半群 Semigroup][Semigroup]
 *  [Foldable][]
 *  [类型签名 Type Signatures][Type Signatures]
 *  [代数数据类型 Algebraic data type][Algebraic data type]
    
     *  [Sum type][]
     *  [Product type][]
 *  [Option][]
 *  [JavaScript 中的函数式编程库 Functional Programming Libraries in JavaScript][JavaScript _ Functional Programming Libraries in JavaScript]

## Arity ##

函数所需的参数个数。来自于单词 unary, binary, ternary 等等。这个单词是由 `-ary` 与 `-ity` 两个后缀组成。例如，一个带有两个参数的函数被称为二元函数或者它的 arity 是2。它也被那些更喜欢希腊词根而非拉丁词根的人称为 `dyadic`。同样地，带有可变数量参数的函数被称为 `variadic`，而二元函数必须给出两个且只有两个参数，见下文，柯里化(Currying) 和 偏应用函数(Partial Application) 。

JavaScript代码:

1.  const sum =(a, b)=> a \+ b
2.   
3.  const arity = sum.length
4.  console.log(arity)// 2
5.   
6.  // The arity of sum is 2

## 高阶函数 Higher-Order Functions (HOF) ##

一个函数，以函数为参数 或/和 返回一个函数。

JavaScript代码:

1.  const filter =(predicate, xs)=> xs.filter(predicate)

JavaScript代码:

1.  constis=(type)=>(x)=>Object(x)instanceof type

JavaScript代码:

1.  filter(is(Number),\[0,'1',2,null\])// \[0, 2\]

## 偏应用函数 Partial Application ##

偏应用一个函数意思是通过预先填充原始函数的部分(不是全部)参数来创建一个新函数。

JavaScript代码:

1.  // 创建偏应用函数
2.  // 带一个函数参数 和 该函数的部分参数
3.  constpartial=(f,...args)=>
4.  // 返回一个带有剩余参数的函数
5.  (...moreArgs)=>
6.  // 通过全部参数调用原始函数
7.   f(...args,...moreArgs)
8.   
9.  // 原始函数
10. const add3 =(a, b, c)=> a \+ b \+ c
11.  
12. // 偏应用 \`2\` 和 \`3\` 到 \`add3\` 给你一个单参数的函数
13. const fivePlus =partial(add3,2,3)// (c) => 2 + 3 + c
14.  
15. fivePlus(4)// 9

你也可以使用 `Function.prototype.bind` 来实现偏应用函数:

JavaScript代码:

1.  const add1More = add3.bind(null,2,3)// (c) => 2 + 3 + c

偏应用函数应用通过对复杂的函数填充一部分数据来构成一个简单的函数。[柯里化(Curried)][Currying] 通过偏应用函数实现。

## Currying ##

将多个参数的函数(多元函数) 转换为 一元函数的过程。

每当函数被调用时，它仅仅接收一个参数并且返回带有一个参数的函数，直到所有的参数传递完成。

JavaScript代码:

1.  const sum =(a, b)=> a \+ b
2.   
3.  const curriedSum =(a)=>(b)=> a \+ b
4.   
5.  curriedSum(40)(2)// 42.
6.   
7.  const add2 = curriedSum(2)// (b) => 2 + b
8.   
9.  add2(10)// 12
10.

## 闭包 Closure ##

闭包是访问其作用域之外的变量的一种方法。正式一点的解释，闭包是一种用于实现词法作用域的命名绑定的技术。它是一种用环境存储函数的方法。

闭包是一个作用域，在这个作用域能够捕获访问函数的局部变量，即使执行已经从定义它的块中移出。即，它们允许在声明变量的块执行完成之后保持对作用域的引用。

JavaScript代码:

1.  const addTo = x => y => x \+ y
2.  var addToFive = addTo(5)
3.  addToFive(3)// returns 8

函数 `addTo()` 返回一个函数（内部调用 `add()` ），将它存储在一个名为 `addToFive` 的变量中，并柯里化(Curried)调用，参数为 5 。

通常，当函数 `addTo` 完成执行时，其作用域与局部变量 `add`，`x`，`y` 不可访问。但是，它在调用 `addToFive()` 时返回 8。这意味着即使代码块执行完成后，函数 `addTo` 的状态也被保存，否则无法知道 `addTo` 被调用为 `addTo(5)`，`x` 的值设置为 5。

词法作用域是能够找到 `x` 和 `add` 的值的原因 – 已完成执行的父级私有变量。这就称为 Closure(闭包) 。

堆栈伴随着函数的词法作用域存储在父对象的引用形式中。这样可以防止闭包和底层变量被当做垃圾回收（因为至少有一个实时引用）。

Lambda Vs Closure(闭包) ：lambda 本质上是一个内联定义的函数，而不是声明函数的标准方法。lambda 经常可以作为对象传递。

闭合是一个函数，通过引用其函数体外部的字段来保持对外部变量的引用。

进一步阅读 / 来源  
\* [Lambda Vs Closure][]  
\* [How do JavaScript Closures Work?][How do JavaScript Closures Work]

## 自动柯里化 Auto Currying ##

将一个将多个参数的函数转换为一个参数的函数，如果给定的参数数量少于正确的参数，则返回一个函数，该函数将获得其余的参数。当函数得到正确数量的参数时，它就会被求值。

lodash 和 Ramda 都有一个 `curry` 函数，使用的就是这种工作方式。

JavaScript代码:

1.  constadd=(x, y)=> x \+ y
2.   
3.  const curriedAdd = \_.curry(add)
4.  curriedAdd(1,2)// 3
5.  curriedAdd(1)// (y) => 1 + y
6.  curriedAdd(1)(2)// 3

进一步阅读\* [Favoring Curry][]\* [Hey Underscore, You’re Doing It Wrong!][Hey Underscore_ You_re Doing It Wrong]

## 函数合成 Function Composition ##

将两个函数合成在一起构成第三个函数，其中一个函数的输出是另一个函数的输入。

JavaScript代码:

1.  const compose =(f, g)=>(a)=> f(g(a))// Definition
2.  const floorAndToString = compose((val)=> val.toString(),Math.floor)// Usage
3.  floorAndToString(121.212121)// '121'

## Continuation ##

在一个程序执行的任意时刻，尚未执行的代码称为 Continuation。

JavaScript代码:

1.  const printAsString =(num)=> console.log(\`Given $\{num\}\`)
2.   
3.  const addOneAndContinue =(num, cc)=>\{ 
4.  const result = num \+1
5.   cc(result)
6.  \}
7.   
8.  addOneAndContinue(2, printAsString)// 'Given 3'

Continuation 在异步编程中很常见，当程序需要等待接收数据才能继续执行。一旦接收到数据，请求响应通常会被传递给程序的剩余部分，这个剩余部分就是 Continuation。

JavaScript代码:

1.  const continueProgramWith =(data)=>\{ 
2.  // 通过 data 继续执行
3.  \}
4.   
5.  readFileAsync('path/to/file',(err, response)=>\{ 
6.  if(err)\{ 
7.  // 错误处理
8.  return
9.  \}
10.  continueProgramWith(response)
11. \})

## 纯函数 Purity ##

如果返回值仅由其输入值决定，并且不产生副作用，那么这个函数就是纯函数。

JavaScript代码:

1.  const greet =(name)=>\`Hi, $\{name\}\`
2.   
3.  greet('Brianne')// 'Hi, Brianne'

以下代码不是纯函数：

JavaScript代码:

1.  window.name ='Brianne'
2.   
3.  const greet =()=>\`Hi, $\{window.name\}\`
4.   
5.  greet()// "Hi, Brianne"

上述示例的输出基于存储在函数外部的数据…

JavaScript代码:

1.  let greeting
2.   
3.  const greet =(name)=>\{ 
4.   greeting =\`Hi, $\{name\}\`
5.  \}
6.   
7.  greet('Brianne')
8.  greeting // "Hi, Brianne"

… 而这个示例则是修改了函数外部的状态。

## 副作用 Side effects ##

函数或表达式如果被认为具有副作用，那么除了返回值之外，它可以与外部可变状态（读取或写入）进行交互。

JavaScript代码:

1.  const differentEveryTime =newDate()

JavaScript代码:

1.  console.log('IO is a side effect!')

## 幂等 Idempotent ##

将一个函数重新应用其结果，如果产生的结果是相同的，那么该函数是幂等的。

A function is idempotent if reapplying it to its result does not produce a different result.

f(f(x)) ≍ f(x)

JavaScript代码:

1.  Math.abs(Math.abs(10))

JavaScript代码:

1.  sort(sort(sort(\[2,1\])))

## Point-Free Style ##

定义函数时，没有显式地标识所使用的参数。这种风格通常需要 [currying(柯里化)][Currying] 或 [高阶函数][Higher-Order Functions _HOF]。 也叫 Tacit programming。

JavaScript代码:

1.  // 给定
2.  const map =(fn)=>(list)=> list.map(fn)
3.  constadd=(a)=>(b)=> a \+ b
4.   
5.  // 然后
6.   
7.  // 非 points-free - \`numbers\` 是一个明确的参数
8.  const incrementAll =(numbers)=> map(add(1))(numbers)
9.   
10. // Points-free - \`list\` 显式地标识
11. const incrementAll2 = map(add(1))

`incrementAll` 明确的使用了参数 `numbers`，所以它是非 points-free 风格。 `incrementAll2` 连接函数与值，并不提及它的参数。所以 是 points-free 风格.

Point-Free 风格的函数就像平常的赋值，不使用 `function` 或者 `=>`。

## 断言 Predicate ##

断言函数是根据给定值返回 `true`或 `false` 的函数。断言函数的常见用法是作为数组过滤器的回调。

JavaScript代码:

1.  const predicate =(a)=> a >2
2.   
3.  ;\[1,2,3,4\].filter(predicate)// \[3, 4\]

## 约定 Contracts ##

约定运行时从函数或表达式中指定行为的义务和保证。这就像一组规则，这些规则是由函数或表达式的输入和输出所期望的，并且当违反契约时，通常会抛出错误。

JavaScript代码:

1.  // 定义约定 : int -> int
2.  const contract =(input)=>\{ 
3.  if(typeof input ==='number')returntrue
4.  thrownewError('Contract violated: expected int -> int')
5.  \}
6.   
7.  const addOne =(num)=> contract(num)&& num \+1
8.   
9.  addOne(2)// 3
10. addOne('some string')// Contract violated: expected int -> int

## Category ##

在范畴论中，范畴是指对象集合及它们之间的态射 (morphism)。在编程中，数据类型作为对象，函数作为态射。

一个有效的范畴遵从以下三个原则：

1.  必有一个 identity 态射，使得 map 一个对象是它自身。`a` 是范畴里的一个对象时，必有一个函数使 `a -> a`。
2.  态射必是可组合的。`a`，`b`，`c` 是范畴里的对象，`f` 是态射 `a -> b`，`g` 是 `b -> c`态射。`g(f(x))` 一定与 `(g • f)(x)` 是等价的。
3.  合成满足结合律。`f • (g • h)` 与 `(f • g) • h` 是等价的。

这些准则是非常抽象的，范畴论对与发现组合的新方法是伟大的。

进一步阅读

*  [Category Theory for Programmers][]

## 值 Value ##

任何可以分配给变量的东西称作值。

JavaScript代码:

1.  5
2.  Object.freeze(\{ name:'John', age:30\})// \`freeze\` 强制实现不可变性。
3.  ;(a)=> a
4.  ;\[1\]
5.  undefined

## Constant ##

一旦定义不可重新赋值的变量。

JavaScript代码:

1.  const five =5
2.  const john =Object.freeze(\{ name:'John', age:30\})

常量是[引用透明][Referential Transparency]的，因此它们可以被它们所代表的值替代而不影响结果。

对于以上两个常量，以下语句总会返回 true。

JavaScript代码:

1.  john.age \+ five ===(\{ name:'John', age:30\}).age \+(5)

## 函子 Functor ##

一个实现 `map` 函数的对象，它在运行对象中的每个值以生成一个新对象，时遵守两个规则：

一致性

JavaScript代码:

1.  object.map(x => x)≍object

合成性

JavaScript代码:

1.  object.map(compose(f, g))≍object.map(g).map(f)

(`f`, `g` be arbitrary functions)

在 javascript 中一个常见的函子是 `Array` , 因为它遵守因子的两个准则。

JavaScript代码:

1.  ;\[1,2,3\].map(x => x)// = \[1, 2, 3\]

和

JavaScript代码:

1.  const f = x => x \+1
2.  const g = x => x \*2
3.   
4.  ;\[1,2,3\].map(x => f(g(x)))// = \[3, 5, 7\]
5.  ;\[1,2,3\].map(g).map(f)// = \[3, 5, 7\]

## Pointed Functor ##

一个具有 `of` 函数的对象，它将 任何 单独的值放入其中。

ES2015 增加了 `Array.of` ，使数组成为一个 Pointed Functor 。

JavaScript代码:

1.  Array.of(1)// \[1\]

## 提升 Lift ##

提升就是当你取一个值并将其放入一个像[functor][Pointed Functor]这样的对象。如果你把一个函数提升到一个 [Applicative Functor][]中，那么你可以使它在那个函子中的值也可以工作。

有些实现提供了一个名为 `lift` 或 `liftA2` 的函数，可以使函数在 函子 上更容易运行。

JavaScript代码:

1.  const liftA2 =(f)=>(a, b)=> a.map(f).ap(b)// 注意这里提升的是 \`ap\` ，而不是 \`map\` 。
2.   
3.  const mult = a => b => a \* b
4.   
5.  const liftedMult = liftA2(mult)// 这个函数现在能在函子上像数组一样工作
6.   
7.  liftedMult(\[1,2\],\[3\])// \[3, 6\]
8.  liftA2(a => b => a \+ b)(\[1,2\],\[3,4\])// \[4, 5, 5, 6\]

提升一个单参数函数并应用它，那么它和 `map` 做一样的事情。

JavaScript代码:

1.  const increment =(x)=> x \+1
2.   
3.  lift(increment)(\[2\])// \[3\]
4.  ;\[2\].map(increment)// \[3\]

## 引用透明性 Referential Transparency ##

在不改变程序行为的情况下，一个表达式能够被它的值替代，这被认为是引用透明。

比方说，我们有一个 greet 函数：

JavaScript代码:

1.  const greet =()=>'Hello World!'

`greet()` 的任何调用可以用 `Hello World!` 代替！因此 greet 被认为是引用透明。

## 等式推理 Equational Reasoning ##

当应用程序由表达式组成，并且没有副作用时，关于系统的真值可以从各个部分推导出来。

## Lambda ##

一个匿名函数，被当作一个值来对待。

JavaScript代码:

1.  ;(function(a)\{ 
2.  return a \+1
3.  \})
4.   
5.  ;(a)=> a \+1

匿名函数通常作为高阶函数的参数

JavaScript代码:

1.  ;\[1,2\].map((a)=> a \+1)// \[2, 3\]

可以把 Lambda 赋值给一个变量

JavaScript代码:

1.  const add1 =(a)=> a \+1

## λ演算 Lambda Calculus ##

数学的一个分支，使用函数创造 [通过计算模型][Link 1]

## 惰性求值 Lazy evaluation ##

惰性求值是一种按需求值机制，它会延迟对表达式的求值，直到其需要为止。在函数式语言中，这允许像无限列表这样的结构，通常情况下排序重要的命令语言不可用。

JavaScript代码:

1.  const rand =function\*()\{ 
2.  while(1<2)\{ 
3.  yieldMath.random()
4.  \}
5.  \}

JavaScript代码:

1.  const randIter = rand()
2.  randIter.next()// 每个执行都给出一个随机值，表达式按需求值。

## Monoid ##

一个对象拥有一个函数用来连接相同类型的对象。

数值加法是一个简单的 Monoid ：

JavaScript代码:

1.  1\+1// 2

以上示例中，数值是对象而 `+` 是函数。

与另一个值结合而不会改变它的值必须存在，称为 `identity`。

加法的 `identity` 值为 0:

JavaScript代码:

1.  1\+0// 1

需要满足结合律

JavaScript代码:

1.  1\+(2\+3)===(1\+2)\+3// true

数组的结合也是 Monoid

JavaScript代码:

1.  ;\[1,2\].concat(\[3,4\])// \[1, 2, 3, 4\]

identity 的值为空数组 `[]`

JavaScript代码:

1.  ;\[1,2\].concat(\[\])// \[1, 2\]

identity 与 compose 函数能够组成 monoid

JavaScript代码:

1.  const identity =(a)=> a
2.  const compose =(f, g)=>(x)=> f(g(x))

`foo` 是只带一个参数的任意函数。

JavaScript代码:

1.  compose(foo, identity)≍ compose(identity, foo)≍ foo

## Monad ##

monad是一个具有 [`of`][Pointed Functor] 和 `chain` 函数的对象。`chain` 就像 [`map`][Functor] ， 除了用来铺平嵌套数据。

JavaScript代码:

1.  // 实现
2.  Array.prototype.chain =function(f)\{ 
3.  returnthis.reduce((acc, it)=> acc.concat(f(it)),\[\])
4.  \}
5.   
6.  // 用法
7.  Array.of('cat,dog','fish,bird').chain((a)=> a.split(','))// \['cat', 'dog', 'fish', 'bird'\]
8.   
9.  // 对比 map 
10. Array.of('cat,dog','fish,bird').map((a)=> a.split(','))// \[\['cat', 'dog'\], \['fish', 'bird'\]\]

在有些语言中，`of` 也称为 `return`，`chain` 也称为 `flatmap` 与 `bind`。

## Comonad ##

拥有 `extract` 与 `extend` 函数的对象。

JavaScript代码:

1.  constCoIdentity=(v)=>(\{ 
2.   val: v,
3.   extract ()\{ 
4.  returnthis.val
5.  \},
6.   extend (f)\{ 
7.  returnCoIdentity(f(this))
8.  \}
9.  \})

从函子中 `extract` (提取) 出一个值。

JavaScript代码:

1.  CoIdentity(1).extract()// 1

Extend 在 comonad 上运行一个函数。函数应该返回与 comonad 相同的类型。

JavaScript代码:

1.  CoIdentity(1).extend((co)=> co.extract()\+1)// CoIdentity(2)

## Applicative Functor ##

应用函子是具有`ap`函数的对象。 `ap`将对象中的函数应用于同一类型的另一个对象中的值。

JavaScript代码:

1.  // 实现
2.  Array.prototype.ap =function(xs)\{ 
3.  returnthis.reduce((acc, f)=> acc.concat(xs.map(f)),\[\])
4.  \}
5.   
6.  // 使用示例
7.  ;\[(a)=> a \+1\].ap(\[1\])// \[2\]

如果你有两个对象，并需要对他们的元素执行一个二元函数

JavaScript代码:

1.  // 你想合成的数组
2.  const arg1 =\[1,3\]
3.  const arg2 =\[4,5\]
4.   
5.  // 合成函数 - 必须为此 curried 柯里化 才能工作
6.  constadd=(x)=>(y)=> x \+ y
7.   
8.  const partiallyAppliedAdds =\[add\].ap(arg1)// \[(y) => 1 + y, (y) => 3 + y\]

由此得到了一个函数数组，并且可以调用 `ap` 函数得到结果：

JavaScript代码:

1.  partiallyAppliedAdds.ap(arg2)// \[5, 6, 7, 8\]

## 态射 Morphism ##

一个变形的函数。

### 自同态 Endomorphism ###

输入输出是相同类型的函数。

JavaScript代码:

1.  // uppercase :: String -> String
2.  const uppercase =(str)=> str.toUpperCase()
3.   
4.  // decrement :: Number -> Number
5.  const decrement =(x)=> x \-1

### 同构 Isomorphism ###

不用类型对象的变形，保持结构并且不丢失数据。

例如，一个二维坐标既可以表示为数组 `[2, 3]`，也可以表示为对象 `{x: 2, y: 3}`。

JavaScript代码:

1.  // 提供函数在两种类型间互相转换
2.  const pairToCoords =(pair)=>(\{ x: pair\[0\], y: pair\[1\]\})
3.   
4.  const coordsToPair =(coords)=>\[coords.x, coords.y\]
5.   
6.  coordsToPair(pairToCoords(\[1,2\]))// \[1, 2\]
7.   
8.  pairToCoords(coordsToPair(\{ x:1, y:2\}))// \{x: 1, y: 2\}

## Setoid ##

拥有 `equals` 函数的对象。`equals` 可以用来和其它对象比较。

使数组成为一个 setoid:

JavaScript代码:

1.  Array.prototype.equals =function(arr)\{ 
2.  const len =this.length
3.  if(len !== arr.length)\{ 
4.  returnfalse
5.  \}
6.  for(let i =0; i < len; i\++)\{ 
7.  if(this\[i\]!== arr\[i\])\{ 
8.  returnfalse
9.  \}
10. \}
11. returntrue
12. \}
13.  
14. ;\[1,2\].equals(\[1,2\])// true
15. ;\[1,2\].equals(\[0\])// false

## 半群 Semigroup ##

一个拥有 `concat` 函数的对象。`concat` 可以连接相同类型的两个对象。

JavaScript代码:

1.  ;\[1\].concat(\[2\])// \[1, 2\]

## Foldable ##

一个拥有 `reduce` 函数的对象。`reduce` 可以把一种类型的对象转化为另一种类型。

JavaScript代码:

1.  const sum =(list)=> list.reduce((acc, val)=> acc \+ val,0)
2.  sum(\[1,2,3\])// 6

## 类型签名 Type Signatures ##

通常，JavaScript 中的函数会包含一些注释，这些注释指明了它们的参数和返回值的类型。

整个社区有很大的差异，但是他们经常遵循以下模式：

JavaScript代码:

1.  // functionName :: firstArgType -> secondArgType -> returnType
2.   
3.  // add :: Number -> Number -> Number
4.  constadd=(x)=>(y)=> x \+ y
5.   
6.  // increment :: Number -> Number
7.  const increment =(x)=> x \+1

如果函数的参数也是函数，那么这个函数需要用括号括起来。

JavaScript代码:

1.  // call :: (a -> b) -> a -> b
2.  const call =(f)=>(x)=> f(x)

字符 `a`， `b`，`c`，`d` 用于表示参数可以是任何类型。 以下版本的 `map` 采用将某种类型 `a` 的值转换为另一个类型`b`的函数，这是一个类型为 `a` 的数组，并返回一个类型为 `b` 的数组。

JavaScript代码:

1.  // map :: (a -> b) -> \[a\] -> \[b\]
2.  const map =(f)=>(list)=> list.map(f)

进一步阅读  
\* [Ramda’s type signatures][Ramda_s type signatures]  
\* [Mostly Adequate Guide][]  
\* [What is Hindley-Milner?][What is Hindley-Milner] on Stack Overflow

## 代数数据类型 Algebraic data type ##

由其他类型组合在一起的复合类型。两种常见的代数类型是 [sum][Sum type] 和 [product][Product type] 。

### Sum 类型 ###

Sum 类型是将两种类型的组合合并成另一种类型。它之所以被称为 sum ，是因为结果类型中可能的值的数量是输入类型的总和。

JavaScript 没有这样的类型，但是我们可以使用 `Set` 来假装：

JavaScript代码:

1.  // 想象一下，在这里我们不能设置只能具有这些值的类型
2.  const bools =newSet(\[true,false\])
3.  const halfTrue =newSet(\['half-true'\])
4.   
5.  // 弱逻辑类型包含 bools 和 halfTrue 值的总和
6.  const weakLogicValues =newSet(\[...bools,...halfTrue\])

Sum 类型有时称为联合类型 (Union Type)， discriminated unions, 或 tagged unions。

JS中有 [couple][] [libraries][] 可以帮助定义和使用联合类型。

Flow 包含 [union types][] ，TypeScript具有[Enums][] 以提供相同的角色。

### Product type ###

product 类型将类型合并在一起，您可能更熟悉以下方面：

JavaScript代码:

1.  // point :: (Number, Number) -> \{x: Number, y: Number\}
2.  const point =(x, y)=>(\{ x: x, y: y\})

它被称为 product ，因为数据结构的总可能值是不同值的乘积。许多语言具有元组类型，它是产品类型的最简单的公式。

参见 [Set theory][].

## Option ##

Option 是一种[sum type][Sum type] ，它有两种情况，`Some` 或者 `None`。

Option 对于组合可能不返回值的函数很有用。

JavaScript代码:

1.  // 定义
2.   
3.  constSome=(v)=>(\{ 
4.   val: v,
5.   map (f)\{ 
6.  returnSome(f(this.val))
7.  \},
8.   chain (f)\{ 
9.  return f(this.val)
10. \}
11. \})
12.  
13. constNone=()=>(\{ 
14.  map (f)\{ 
15. returnthis
16. \},
17.  chain (f)\{ 
18. returnthis
19. \}
20. \})
21.  
22. // maybeProp :: (String, \{a\}) -> Option a
23. const maybeProp =(key, obj)=>typeof obj\[key\]==='undefined'?None():Some(obj\[key\])

使用 `chain` 可以序列化返回 `Option` 的函数。

JavaScript代码:

1.   
2.  // getItem :: Cart -> Option CartItem
3.  const getItem =(cart)=> maybeProp('item', cart)
4.   
5.  // getPrice :: Item -> Option Number
6.  const getPrice =(item)=> maybeProp('price', item)
7.   
8.  // getNestedPrice :: cart -> Option a
9.  const getNestedPrice =(cart)=> getItem(obj).chain(getPrice)
10.  
11. getNestedPrice(\{\})// None()
12. getNestedPrice(\{ item:\{ foo:1\}\})// None()
13. getNestedPrice(\{ item:\{ price:9.99\}\})// Some(9.99)

在其它的一些地方，`Option` 也称为 `Maybe`，`Some` 也称为 `Just`，`None` 也称为 `Nothing`。

## JavaScript 中的函数式编程库 ##

*  [mori][]
 *  [Immutable][]
 *  [Ramda][]
 *  [ramda-adjunct][]
 *  [Folktale][]
 *  [monet.js][]
 *  [lodash][]
 *  [Underscore.js][]
 *  [Lazy.js][]
 *  [maryamyriameliamurphies.js][]
 *  [Haskell in ES6][]
 *  [Sanctuary][]

[GitHub地址][GitHub]

[Why JavaScript]: https://github.com/hemanth/functional-programming-jargon/wiki/Why-JavaScript%3F
[Fantasy Land spec]: https://github.com/fantasyland/fantasy-land
[Arity]: http://www.css88.com/archives/7833#arity
[Higher-Order Functions _HOF]: http://www.css88.com/archives/7833#higher-order-functions-hof
[Partial Application]: http://www.css88.com/archives/7833#partial-application
[Currying]: http://www.css88.com/archives/7833#currying
[Closure]: http://www.css88.com/archives/7833#closure
[Auto Currying]: http://www.css88.com/archives/7833#auto-currying
[Function Composition]: http://www.css88.com/archives/7833#function-composition
[Continuation]: http://www.css88.com/archives/7833#continuation
[Purity]: http://www.css88.com/archives/7833#purity
[Side effects]: http://www.css88.com/archives/7833#side-effects
[Idempotent]: http://www.css88.com/archives/7833#idempotent
[Point-Free Style]: http://www.css88.com/archives/7833#point-free-style
[Predicate]: http://www.css88.com/archives/7833#predicate
[Contracts]: http://www.css88.com/archives/7833#contracts
[Category]: http://www.css88.com/archives/7833#category
[Value]: http://www.css88.com/archives/7833#value
[Constant]: http://www.css88.com/archives/7833#constant
[Functor]: http://www.css88.com/archives/7833#functor
[Pointed Functor]: http://www.css88.com/archives/7833#pointed-functor
[Lift]: http://www.css88.com/archives/7833#lift
[Referential Transparency]: http://www.css88.com/archives/7833#referential-transparency
[Equational Reasoning]: http://www.css88.com/archives/7833#equational-reasoning
[Lambda]: http://www.css88.com/archives/7833#lambda
[Lambda Calculus]: http://www.css88.com/archives/7833#lambda-calculus
[Lazy evaluation]: http://www.css88.com/archives/7833#lazy-evaluation
[Monoid]: http://www.css88.com/archives/7833#monoid
[Monad]: http://www.css88.com/archives/7833#monad
[Comonad]: http://www.css88.com/archives/7833#comonad
[Applicative Functor]: http://www.css88.com/archives/7833#applicative-functor
[Morphism]: http://www.css88.com/archives/7833#morphism
[Endomorphism]: http://www.css88.com/archives/7833#endomorphism
[Isomorphism]: http://www.css88.com/archives/7833#isomorphism
[Setoid]: http://www.css88.com/archives/7833#setoid
[Semigroup]: http://www.css88.com/archives/7833#semigroup
[Foldable]: http://www.css88.com/archives/7833#foldable
[Type Signatures]: http://www.css88.com/archives/7833#type-signatures
[Algebraic data type]: http://www.css88.com/archives/7833#algebraic-data-type
[Sum type]: http://www.css88.com/archives/7833#sum-type
[Product type]: http://www.css88.com/archives/7833#product-type
[Option]: http://www.css88.com/archives/7833#option
[JavaScript _ Functional Programming Libraries in JavaScript]: http://www.css88.com/archives/7833#functional-programming-libraries-in-javascript
[Lambda Vs Closure]: http://stackoverflow.com/questions/220658/what-is-the-difference-between-a-closure-and-a-lambda
[How do JavaScript Closures Work]: http://stackoverflow.com/questions/111102/how-do-javascript-closures-work
[Favoring Curry]: http://fr.umio.us/favoring-curry/
[Hey Underscore_ You_re Doing It Wrong]: https://www.youtube.com/watch?v=m3svKOdZijA
[Category Theory for Programmers]: https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/
[Link 1]: https://en.wikipedia.org/wiki/Lambda_calculus
[Ramda_s type signatures]: https://github.com/ramda/ramda/wiki/Type-Signatures
[Mostly Adequate Guide]: https://drboolean.gitbooks.io/mostly-adequate-guide/content/ch7.html#whats-your-type
[What is Hindley-Milner]: http://stackoverflow.com/a/399392/22425
[couple]: https://github.com/paldepind/union-type
[libraries]: https://github.com/puffnfresh/daggy
[union types]: https://flow.org/en/docs/types/unions/
[Enums]: https://www.typescriptlang.org/docs/handbook/enums.html
[Set theory]: https://en.wikipedia.org/wiki/Set_theory
[mori]: https://github.com/swannodette/mori
[Immutable]: https://github.com/facebook/immutable-js/
[Ramda]: https://github.com/ramda/ramda
[ramda-adjunct]: https://github.com/char0n/ramda-adjunct
[Folktale]: http://folktalejs.org/
[monet.js]: https://cwmyers.github.io/monet.js/
[lodash]: https://github.com/lodash/lodash
[Underscore.js]: https://github.com/jashkenas/underscore
[Lazy.js]: https://github.com/dtao/lazy.js
[maryamyriameliamurphies.js]: https://github.com/sjsyrek/maryamyriameliamurphies.js
[Haskell in ES6]: https://github.com/casualjavascript/haskell-in-es6
[Sanctuary]: https://github.com/sanctuary-js/sanctuary
[GitHub]: https://github.com/hemanth/functional-programming-jargon