摘要：以此類推，不定參數(shù)的方程也就被稱為可變參數(shù)函數(shù)。一般來(lái)說(shuō)，函數(shù)式編程中的值都被認(rèn)為是不可變值。實(shí)現(xiàn)了函數(shù)的對(duì)象，即可以與其他對(duì)象進(jìn)行對(duì)比判斷是否屬于同一類型，被稱為。半群一個(gè)擁有，即將另一個(gè)對(duì)象轉(zhuǎn)化為相同類型的函數(shù)，函數(shù)的對(duì)象稱為。

原文地址
譯者的Github 系列文章地址
本文原作者尚未全部完成，有興趣的可以到原文或者譯文地址關(guān)注更新

本文的主要目的即是希望能夠有一種通俗易懂的方式來(lái)闡述函數(shù)式編程中常見(jiàn)的理論術(shù)語(yǔ)概念

Arity代指一個(gè)函數(shù)的參數(shù)數(shù)量，該關(guān)鍵字來(lái)源于類似于unary、binary、ternary等等，由兩個(gè)后綴-ary、-ity組成。譬如，如果一個(gè)函數(shù)允許輸入兩個(gè)參數(shù)，那就稱為所謂的binary function(二元函數(shù))，或者一個(gè)有兩個(gè)參數(shù)的函數(shù)。有時(shí)候這種函數(shù)也會(huì)被喜歡拉丁語(yǔ)法的人稱為"dyadic(二價(jià)的)"函數(shù)。以此類推，不定參數(shù)的方程也就被稱為variadic(可變參數(shù)函數(shù))。

const sum = (a, b) => a + b;

const arity = sum.length;
console.log(arity);
// => 2
// The arity of sum is 2

一個(gè)接收某個(gè)函數(shù)作為參數(shù)的函數(shù)成為高等函數(shù)，該函數(shù)可以選擇返回一個(gè)函數(shù)也可以返回其他類型

const filter = (pred, xs) => {
  const result = [];
  for (var idx = 0; idx < xs.length; idx += 1) {
    if (pred(xs[idx])) {
      result.push(xs[idx]);
    }
  }
  return result;
};

const is = type => x => Object(x) instanceof type;

filter(is(Number), [0, "1", 2, null]); //=> [0, 2]

將原本一個(gè)多參數(shù)值的函數(shù)封裝為固定參數(shù)數(shù)目的函數(shù)的過(guò)程稱為Partial Application

let sum = (a, b) => a + b;

// partially applying `a` to `40`
let partial = sum.bind(null, 40);

// Invoking it with `b`
partial(2); //=> 42

將一個(gè)N參數(shù)值的函數(shù)轉(zhuǎn)化為N個(gè)一元函數(shù)的組合，Currying與Partial Application的區(qū)別在于Partial Application最終生成的函數(shù)允許接收多個(gè)值，而Currying生成的函數(shù)序列中的每個(gè)函數(shù)只允許接收一個(gè)參數(shù)

let sum = (a, b) => a + b;

let curriedSum = (a) => (b) => a + b;

curriedSum(40)(2) // 42.

感覺(jué)有點(diǎn)像設(shè)計(jì)模式里的Decorator，即能夠?qū)蓚€(gè)指定類型組合轉(zhuǎn)化為一個(gè)新值的函數(shù)

最常見(jiàn)的組合即是常見(jiàn)的函數(shù)組合，允許你將不同的函數(shù)組合成一個(gè)返回單值的函數(shù)

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

一個(gè)沒(méi)有任何副作用，并且返回值只由輸入決定的函數(shù)成為純函數(shù)

let greet = "yo";

greet.toUpperCase(); // YO;

greet // yo;

As opposed to:

let numbers = [1, 2, 3];

numbers.splice(0); // [1, 2, 3]

numbers // []

如果一個(gè)函數(shù)，除了返回值之外，還會(huì)修改某些其它狀態(tài)，或者與外部函數(shù)等有可觀測(cè)的交互

console.log("IO is a side effect!");

多次執(zhí)行下都不會(huì)產(chǎn)生副作用的函數(shù)被稱為具有冪等性的函數(shù)

f(f(x)) = f(x)

Math.abs(Math.abs(10))

那些并沒(méi)有線性定義參數(shù)的函數(shù)風(fēng)格被稱為Point-Free Style，這類型往往需要currying 或者 Higher-Order functions。

// Given
let map = fn => list => list.map(fn);
let add = (a, b) => a + b;

// Then

// Not points-free - `numbers` is an explicit parameter
let incrementAll = (numbers) => map(add(1))(numbers);

// Points-free - The list is an implicit parameter
let incrementAll2 = map(add(1));

incrementAll明確規(guī)定了參數(shù)numbers, 而incrementAll2是對(duì)于參數(shù)的封裝，并沒(méi)有顯性說(shuō)明numbers參數(shù)，因此它可以被稱為Points Free。一般來(lái)說(shuō)，Points-free的函數(shù)都不會(huì)用常見(jiàn)的function或者=>關(guān)鍵字來(lái)定義。

關(guān)聯(lián)到遵循某些規(guī)則的函數(shù)的對(duì)象，譬如monoid

計(jì)算中常用到的一些復(fù)合值(complex)或者簡(jiǎn)單值(primitive)，包括函數(shù)。一般來(lái)說(shuō)，函數(shù)式編程中的值都被認(rèn)為是不可變值。

5
Object.freeze({name: "John", age: 30}) // The `freeze` function enforces immutability.
(a) => a

注意，譬如Functor, Monad這樣包含其他值的結(jié)構(gòu)體本身也是值，這就是說(shuō)，這些復(fù)合值也可以相互包含。

對(duì)于一個(gè)值的不可變引用，不能跟變量相混淆。Variable即指那些可能在任意點(diǎn)唄更改的引用。

const five = 5
const john = {name: "John", age: 30}

常量一般認(rèn)為是透明的，也就是說(shuō)，它們可以被值本身代替而不影響最終的計(jì)算結(jié)果，上面的兩個(gè)常量也可以用下述方式表述：

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

上述表達(dá)式會(huì)一直返回真。

Functor即指那些可以引用map函數(shù)的對(duì)象，JavaScript中最簡(jiǎn)單的函數(shù)就是Array。

[2,3,4].map( n => n * 2 ); // [4,6,8]

假設(shè)func構(gòu)造為一個(gè)實(shí)現(xiàn)了map函數(shù)的對(duì)象，f、g則是任意的函數(shù)，只要func遵循以下規(guī)則就可以將func稱為一個(gè)functor:
Let func be an object implementing a map function, and f, g be arbitrary functions, then func is said to be a functor if the map function adheres to the following rules:

func.map(x => x) == func

以及

func.map(x => f(g(x))) == func.map(g).map(f)

我們將Array稱為Functor，也是因?yàn)樗裱艘韵乱?guī)則：

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

以及

let f = x => x + 1;
let g = x => x * 2;

[1, 2, 3].map(x => f(g(x))); // = [3, 5, 7]
[1, 2, 3].map(g).map(f);     // = [3, 5, 7]

實(shí)現(xiàn)了of方法的Functor，Of會(huì)將任何單值轉(zhuǎn)化為一個(gè)Functor

Pointed Functor在Array中的實(shí)現(xiàn)為：

  Array.prototype.of = (v) => [v];
  
  [].of(1) // [1]

Lift很類似于map，不過(guò)它可以用于多個(gè)Functors：

在單值函數(shù)下，Map與Lift的作用是一致的：

lift(n => n * 2)([2,3,4]); // [4,6,8]

而Lift可以允許輸入多個(gè)值：

lift((a, b)  => a * b)([1, 2], [3]); // [3, 6]

一個(gè)可以直接用其值來(lái)替換而不會(huì)影響到程序表現(xiàn)的表達(dá)式稱為透明引用

譬如我們有一個(gè)叫greet的引用

let greet = () => "Hello World!";

當(dāng)一個(gè)應(yīng)用由表達(dá)式組合而成并且沒(méi)有任何副作用的時(shí)候，該系統(tǒng)可以由部分推導(dǎo)而來(lái)

Lazy evaluation 即是所謂的只有在需要某個(gè)值的時(shí)候才進(jìn)行計(jì)算的機(jī)制。在函數(shù)式語(yǔ)言中，這個(gè)機(jī)制就允許對(duì)于那些近乎無(wú)限的列表進(jìn)行操作。

let rand = function*() {
    while(1<2) {
        yield Math.random();
    }
}

let randIter = rand();
randIter.next(); // Each exectuion gives a random value, expression is evaluated on need.

一個(gè)monoid就是與某個(gè)恒等值進(jìn)行組合之后不會(huì)影響現(xiàn)有結(jié)果的數(shù)據(jù)類型

一個(gè)最簡(jiǎn)單的Monoid就是如下所示：

1 + 1; // 2

數(shù)據(jù)類型是number，函數(shù)是+：

1 + 0; // 1

恒等式的值是0,將0與任何數(shù)相加并不會(huì)改變值。有時(shí)候，monoid類型進(jìn)行不同的交換操作也不會(huì)影響結(jié)果：

1 + (2 + 3) == (1 + 2) + 3; // true

數(shù)組連接也可以認(rèn)為是一個(gè)monoid:

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

恒等值即是空數(shù)組： []

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

一個(gè)Monad就是擁有of以及chain函數(shù)的對(duì)象。 Chain 類似于 map只不過(guò)它會(huì)扁平化最終求得的嵌套式結(jié)果。

["cat,dog","fish,bird"].chain(a => a.split(",")) // ["cat","dog","fish","bird"]

//Contrast to map
["cat,dog","fish,bird"].map(a => a.split(",")) // [["cat","dog"], ["fish","bird"]]

You may also see of and chain referred to as return and bind (not be confused with the JS keyword/function...) in languages which provide Monad-like constructs as part of their standard library (e.g. Haskell, F#), on Wikipedia and in other literature. It"s also important to note that return and bind are not part of the Fantasy Land spec and are mentioned here only for the sake of people interested in learning more about Monads.

實(shí)現(xiàn)了extract與extend函數(shù)的對(duì)象

let CoIdentity = v => ({
    val: v,
    extract: this.v,
    extend: f => CoIdentity(f(this))
})

Extract 可以將值從Functor中吐出來(lái)：

CoIdentity(1).extract() // 1

Extend則是會(huì)返回一個(gè)跟Commonad相同值的函數(shù)：

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

一個(gè)Applicative Functor就是一個(gè)實(shí)現(xiàn)了ap函數(shù)的對(duì)象，Ap可以將某個(gè)對(duì)象中的某個(gè)值轉(zhuǎn)化為另一個(gè)對(duì)象中的相同類型的值

[(a)=> a + 1].ap([1]) // [2]

一個(gè)轉(zhuǎn)化函數(shù)

用不同方式存儲(chǔ)的能夠表明相同數(shù)據(jù)的轉(zhuǎn)換

譬如，一個(gè)二維的數(shù)組可以存儲(chǔ)為數(shù)組：[2,3]或者對(duì)象：{x: 2, y: 3}。

// Providing functions to convert in both directions makes them isomorphic.
const pairToCoords = (pair) => ({x: pair[0], y: pair[1]})

const coordsToPair = (coords) => [coords.x, coords.y]

coordsToPair(pairToCoords([1, 2])) // [1, 2]

pairToCoords(coordsToPair({x: 1, y: 2})) // {x: 1, y: 2}

實(shí)現(xiàn)了equals函數(shù)的對(duì)象，即可以與其他對(duì)象進(jìn)行對(duì)比判斷是否屬于同一類型，被稱為Setoid。

下面對(duì)于原型的擴(kuò)充可以將Array變成Setoid。

Array.prototype.equals = arr => {
    var len = this.length
    if (len != arr.length) {
        return false
    }
    for (var i = 0; i < len; i++) {
        if (this[i] !== arr[i]) {
            return false
        }
    }
    return true
}

[1, 2].equals([1, 2]) // true
[1, 2].equals([0]) // false

一個(gè)擁有concat，即將另一個(gè)對(duì)象轉(zhuǎn)化為相同類型的函數(shù)，函數(shù)的對(duì)象稱為Semigroup。

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

實(shí)現(xiàn)了reduce函數(shù)，即可以將一個(gè)對(duì)象轉(zhuǎn)化為其他類型的函數(shù)，的對(duì)象稱為Foldable對(duì)象。

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

一般來(lái)說(shuō)，函數(shù)都會(huì)注釋表明它們的參數(shù)類型和返回值類型

// functionName :: firstArgType -> secondArgType -> returnType

// add :: Number -> Number -> Number
let add = x => y => x + y

// increment :: Number -> Number
let increment = x => x + 1

如果一個(gè)函數(shù)接收其他函數(shù)作為參數(shù)，譬如這樣：

// call :: (a -> b) -> a -> b
let call = f => x => f(x)

這里的a, b, c, d表明參數(shù)可以是任意類型，不過(guò)它會(huì)將類型a轉(zhuǎn)化為另一個(gè)類型b，而對(duì)于下面這個(gè)map，它的注釋表明了它會(huì)輸入一個(gè)a類型的列表，然后轉(zhuǎn)化為另一個(gè)包含了b類型的列表。

// map :: (a -> b) -> [a] -> [b]
let map = f => list =>  list.map(f)