摘要：函數(shù)式編程與面向對象編程表達式函數(shù)柯里化高階函數(shù)之劍什么是表達式例子定義表達式是一個匿名函數(shù)，表達式基于數(shù)學中的演算得名，直接對應于其中的抽象，是一個匿名函數(shù)，即沒有函數(shù)名的函數(shù)。

之劍

2016.5.2 11:19:09

For example, in Lisp the "square" function can be expressed as a lambda expression as follows:

(lambda (x) (* x x))

“Lambda 表達式”(lambda expression)是一個匿名函數(shù)，Lambda表達式基于數(shù)學中的λ演算得名，直接對應于其中的lambda抽象(lambda abstraction)，是一個匿名函數(shù)，即沒有函數(shù)名的函數(shù)。Lambda表達式可以表示閉包（注意和數(shù)學傳統(tǒng)意義上的不同）。

Lambda calculus (also written as λ-calculus) is a formal system in mathematical logic for expressing computation based on function abstraction and application using variable binding and substitution. It was first introduced by mathematician Alonzo Church in the 1930s as part of an investigation into the foundations of mathematics. Lambda calculus is a universal model of computation equivalent to a Turing machine (Church-Turing thesis, 1937). Its namesake, Greek letter lambda (λ), is used in lambda terms (also called lambda expressions) to denote binding a variable in a function.

Lambda calculus may be typed and untyped. In typed lambda calculus functions can be applied only if they are capable of accepting the given input"s "type" of data.

Lambda calculus has applications in many different areas in mathematics, philosophy,linguistics, and computer science. Lambda calculus has played an important role in the development of the theory of programming languages. Functional programming languages implement the lambda calculus. Lambda calculus also is a current research topic in Category theory.

Lambda演算和函數(shù)式語言的計算模型天生較為接近，Lambda表達式一般是這些語言必備的基本特性。如：

Scheme:

    
(lambda(x)(+x1))

Haskell:

    
x->x+1

λ演算是一套用于研究函數(shù)定義、函數(shù)應用和遞歸的形式系統(tǒng)。函數(shù)的作用 (application) 是左結合的：

f x y = (f x) y

它包括一條變換規(guī)則 (變量替換) 和一條函數(shù)定義方式.

比如說,下面的這個圓錐曲線二元二次函數(shù):

$$f(x,y)=x^2+y^2$$

讓我們用其他的一些方式來表達:

$$(x,y) rightarrow x^2 + y^2$$

$$x rightarrow (y rightarrow x^2 + y^2 )$$

為了更加簡單的理解其演算過程, 分解各個步驟如下:

數(shù)學函數(shù)表達式: (f(5,2) = 5^2 + 2^2 = 29)

匿名函數(shù)式:( ((x,y) rightarrow (x^2 + y^2)) (5,2) = 5^2 + 2^2 = 29)

柯里化函數(shù)式: ( (x rightarrow ( y rightarrow (x^2 + y^2) )(5))(2)=(y rightarrow (5^2+y^2))(2) = 5^2+2^2=29 )

λ演算由 Alonzo Church 和 Stephen Cole Kleene 在 20 世紀三十年代引入，Church 運用 lambda 演算在 1936 年給出 判定性問題 (Entscheidungsproblem) 的一個否定的答案。這種演算可以用來清晰地定義什么是一個可計算函數(shù)。關于兩個 lambda 演算表達式是否等價的命題無法通過一個通用的算法來解決，這是不可判定性能夠證明的頭一個問題，甚至還在停機問題之先。Lambda 演算對函數(shù)式編程有巨大的影響，特別是Lisp 語言。

在 lambda 演算中有許多方式都可以定義自然數(shù)，但最常見的還是Church 整數(shù)，下面是它們的定義：

$$ 0 = lambda fcdot lambda xcdot x $$
$$ 1 = lambda fcdot lambda xcdot f x $$
$$ 2 = lambda fcdot lambda xcdot f (f x ) $$
$$ 3 = lambda fcdot lambda xcdot f(f (f x )) $$
$$...$$
$$ n = lambda fcdot lambda xcdot f^n( x ) $$

以此類推。直觀地說，lambda 演算中的數(shù)字 n 就是一個把函數(shù) f 作為參數(shù)并以 f 的 n 次冪為返回值的函數(shù)。換句話說，Church 整數(shù)是一個高階函數(shù) :

 以單一參數(shù)函數(shù) f 為參數(shù)，返回另一個單一參數(shù)的函數(shù)。

(注意在 Church 原來的 lambda 演算中，lambda 表達式的形式參數(shù)在函數(shù)體中至少出現(xiàn)一次，這使得我們無法像上面那樣定義 0)

C#的Lambda 表達式都使用 Lambda 運算符 =>，該運算符讀為“goes to”。語法如下：

形參列表=>函數(shù)體
(input parameters) => expression
(input parameters) => {statement;}

函數(shù)體多于一條語句的可用大括號括起。例子:

() => Console.Write("0個參數(shù)")
I => Console.Write("1個參數(shù)時參數(shù)列中可省略括號，值為：{0}",i)
(x,y) => Console.Write("包含2個參數(shù)，值為：{0}*{1}",x,y)

//兩條語句時必須要大括號
I => { i++;Console.Write("兩條語句的情況"); }

Lambda 表達式是一種可用于創(chuàng)建委托或表達式目錄樹類型的匿名函數(shù)。 通過使用 lambda 表達式，可以寫入可作為參數(shù)傳遞或作為函數(shù)調用值返回的本地函數(shù)。 Lambda 表達式對于編寫 LINQ 查詢表達式特別有用。

若要創(chuàng)建 Lambda 表達式，需要在 Lambda 運算符 => 左側指定輸入?yún)?shù)（如果有），然后在另一側輸入表達式或語句塊。 例如，lambda 表達式 x => x * x 指定名為 x 的參數(shù)并返回 x 的平方值。

過濾條件:

List users = new List();
Func predicate = ((user) =>
    {
        return user.UserId > 100;
    }
);
List temps = users.Where(predicate).ToList();

Java 8的一個大亮點是引入Lambda表達式，使用它設計的代碼會更加簡潔。當開發(fā)者在編寫Lambda表達式時，也會隨之被編譯成一個函數(shù)式接口。下面這個例子就是使用Lambda語法來代替匿名的內(nèi)部類，代碼不僅簡潔，而且還可讀。
沒有使用Lambda的老方法：

Runnable r = new Runnable(){
@Override
public void run(){
    System.out.println("Running without Lambda");
}
};

使用Lambda表達式:

Runnable r =() -> {
    System.out.println("Running without Lambda");
};

ISO C++ 11 標準的一大亮點是引入Lambda表達式?；菊Z法如下：

[capture list] (parameter list) ->return type { function body }

其中除了“[ ]”（其中捕獲列表可以為空）和“復合語句”（相當于具名函數(shù)定義的函數(shù)體），其它都是可選的。它的類型是唯一的具有成員operator()的非聯(lián)合的類類型，稱為閉包類型(closure type)。
C++中，一個lambda表達式表示一個可調用的代碼單元。我們可以將其理解為一個未命名的內(nèi)聯(lián)函數(shù)。它與普通函數(shù)不同的是，lambda必須使用尾置返回來指定返回類型。

scala的匿名函數(shù)使用非常的廣泛，這也是函數(shù)式語言的標志之一。

scala中的集合類List有一個map方法，該方法接收一個函數(shù)作為參數(shù)，對List中的每一個元素使用參數(shù)指定的方法，此處非常適合用匿名函數(shù)，請看下面代碼：

val l=List(1,2,3)
l.map(i=>i+9)

上面代碼的第二行map函數(shù)的參數(shù)就是一個匿名函數(shù)，或者是lambda表達式。

i=>i+9中的=>是參數(shù)列表和返回值的分隔符，如果少于兩個參數(shù)可以不寫小括號，后面部分是函數(shù)的返回值。如果函數(shù)體包含多行代碼可以使用花括號，例如：

l.map((i)=>{
  println("HI");
  i+9
})

定義常規(guī)的scala add函數(shù):

def add (i:Int,j:Int):Int=i+j

這個函數(shù)太簡單了.

我們定義一個devide函數(shù)實現(xiàn)除法，一般我們會這么寫：

// 多參數(shù)的寫法
def multiply(x: Int, y: Int) = x * y

Moses Schnfinkel 和 Gottlob Frege 發(fā)明了如下的表達方式:

def multiply(x: Int)(y: Int) => x * y

這個函數(shù)和上面的函數(shù)不同之處在于它的參數(shù)列表，是一個參數(shù)一個小括號，不是把所有參數(shù)都放到一個括號內(nèi)的。下面我們通過實際的例子來理解scala的curried。

我們要定義一個乘法函數(shù):

// 柯里化的寫法
def multiply(x: Int)(y: Int) = x * y

// 計算兩個數(shù)的乘積
multiply(6)(7)
 

multiply(6)返回的是函數(shù)(y: Int)=>6*y，再將這個函數(shù)應用到7

(6 * y ) (7) = 42

最終得到結果42.

這就是scala的乘法函數(shù)了.

curried不太好理解，enjoy it!函數(shù)柯里化的主要功能是提供了強大的動態(tài)函數(shù)創(chuàng)建方法，通過調用另一個函數(shù)并為它傳入要柯里化（currying）的函數(shù)和必要的參數(shù)而得到。通俗點說就是利用已有的函數(shù)，再創(chuàng)建一個動態(tài)的函數(shù)，該動態(tài)函數(shù)內(nèi)部還是通過已有的函數(shù)來發(fā)生作用.

我們在想, 這些計算機科學家,數(shù)學家們腦子里天天都在想些什么? 盡發(fā)明一些普通人不好理解的概念. 但是, 存在即合理.既然這玩意存在著,必定表明必有其存在之意義.

多參數(shù)是個虛飾，不是編程語言的根本性的特質。利用柯里化把某個函數(shù)參數(shù)多帶帶拎出來，提供更多用于類型推斷的信息.

在計算機科學中，柯里化（Currying）是把接受多個參數(shù)的函數(shù)變換成接受一個單一參數(shù)(最初函數(shù)的第一個參數(shù))的函數(shù)，并且返回接受余下的參數(shù)且返回結果的新函數(shù)的技術。這個技術由 Christopher Strachey 以邏輯學家 Haskell Curry 命名的，盡管它是 Moses Schnfinkel 和 Gottlob Frege 發(fā)明的。

在直覺上，柯里化聲稱“如果你固定某些參數(shù)，你將得到接受余下參數(shù)的一個函數(shù)”。所以對于有兩個變量的函數(shù)yx，如果固定了 y = 2，則得到有一個變量的函數(shù) 2x。
在理論計算機科學中，柯里化提供了在簡單的理論模型中比如只接受一個單一參數(shù)的lambda 演算中研究帶有多個參數(shù)的函數(shù)的方式。

柯里化特性決定了它這應用場景。提前把易變因素，傳參固定下來，生成一個更明確的應用函數(shù)。最典型的代表應用，是bind函數(shù)用以固定this這個易變對象。

Function.prototype.bind = function(context) {
    var _this = this,
    _args = Array.prototype.slice.call(arguments, 1);
    return function() {
        return _this.apply(context, _args.concat(Array.prototype.slice.call(arguments)))
    }
}

柯里化其實本身是固定一個可以預期的參數(shù)，并返回一個特定的函數(shù)。這增加了函數(shù)的適用性，但同時也降低了函數(shù)的適用范圍。這個思路有點像微積分里面的多重積分的處理方式.

柯里化的本質就是函數(shù)參數(shù)單一化. 因為多參數(shù)有其問題.你在寫很多高階函數(shù)的時候，你都得考慮你的 參數(shù)函數(shù)f 在面臨各種傳參方式的情況下要怎么處理，這事兒是痛苦并且容易忘記的，因為你本不應該關心f的參數(shù)是些啥的！盲目地引入傳遞多參的機制，其實是沒有把問題想明白的表現(xiàn)。語法層面支持的多參函數(shù)定義是一種扁平、簡單、有效的方式，但是，當程序需要做高階函數(shù)抽象的時候，這種方式會帶來麻煩。

通過組合型數(shù)據(jù)來傳遞復雜參數(shù)，是一種很自然的方式，這種情況下并不需要刻意考慮“多參函數(shù)”這種問題，并且這種方式對于做高階函數(shù)抽象非常友好。

科里化的方式定義多參函數(shù)，同樣是一種自然產(chǎn)生的方式，只要把函數(shù)當做一等公民，就會存在科里化的方式。科里化的方式使得我們的函數(shù)可以更細粒度地方便地組合。

但是，是否要使用科里化的方式，卻是一件需要細細揣摩的事情。比如，我要定義一個rotate函數(shù)，它接受一個二維向量的坐標，返回一個逆時針旋轉九十度后的向量坐標，那么你可能會把它定義成

rotate = (x -> (y -> (y, -x)))

或者

rotate = ((x, y) -> (y, -x))

你覺得哪種定義方式比較好呢？ 在這個例子里，顯然是第二種定義方式比較好，

一來，二維向量的兩個坐標通常是成對出現(xiàn)的，很少會有“部分應用”的需要，所以也就自然用不到科里化的任何好處；

二來，當你需要把一個向量rotate兩次的時候，科里化版本就會體現(xiàn)出異常的麻煩了。

所以，結論是：

    
    如果某些參數(shù)在大部分情況下，總是需要同時給出，才具有真實的意義，那么應該把這些參數(shù)組合成一個組合型參數(shù)來處理，而不應該科里化。
    如果要定義的多參函數(shù)是一個閉合函數(shù)，那么它是很可能需要被多次應用的，這種情況下，應該用組合型參數(shù)的方式來處理。
    如果先指定某一些參數(shù)就有明確的意義，那么就應該用科里化的方式來處理。

在F#里，各種函數(shù)的signature 都是 int -> int -> int ->什么的……
what does that even mean??
Currying和partial application對于functional programming有怎樣的真正的威力？

currying和partial application會affect performance嗎？

函數(shù)不一定需要名稱：

(x: Double) => 3 * x  // 該匿名函數(shù)將傳給它的參數(shù)乘3

可以將匿名函數(shù)賦值給變量，也可以當參數(shù)傳遞。

以Python內(nèi)置的求絕對值的函數(shù)abs()為例，調用該函數(shù)用以下代碼：

abs(-10)
10

但是，如果只寫abs呢？

abs

可見，abs(-10)是函數(shù)調用，而abs是函數(shù)本身。

要獲得函數(shù)調用結果，我們可以把結果賦值給變量：

 x = abs(-10)
 x
10

但是，如果把函數(shù)本身賦值給變量呢？

f = abs
f

結論：函數(shù)本身也可以賦值給變量，即：變量可以指向函數(shù)。

如果一個變量指向了一個函數(shù)，那么，可否通過該變量來調用這個函數(shù)？用代碼驗證一下：

f = abs
f(-10)
10

成功！說明變量f現(xiàn)在已經(jīng)指向了abs函數(shù)本身。

那么函數(shù)名是什么呢？函數(shù)名其實就是指向函數(shù)的變量！對于abs()這個函數(shù)，完全可以把函數(shù)名abs看成變量，它指向一個可以計算絕對值的函數(shù)！

既然變量可以指向函數(shù)，函數(shù)的參數(shù)能接收變量，那么一個函數(shù)就可以接收另一個函數(shù)作為參數(shù)，這種函數(shù)就稱之為高階函數(shù)。

一個最簡單的高階函數(shù)：

def add(x, y, f):
    return f(x) + f(y)
    
    

當我們調用add(-5, 6, abs)時，參數(shù)x，y和f分別接收-5，6和abs，根據(jù)函數(shù)定義，我們可以推導計算過程為：

x ==> -5
y ==> 6
f ==> abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11

用代碼驗證一下：

add(-5, 6, abs)
11

編寫高階函數(shù)，就是讓函數(shù)的參數(shù)能夠接收別的函數(shù)。

把函數(shù)作為參數(shù)傳入，這樣的函數(shù)稱為高階函數(shù)，函數(shù)式編程就是指這種高度抽象的編程范式。