函數式編程應用

『壹』 輸入m*n階矩陣A和B,用函數編程實現兩個函數相加和相乘

輸入m*n階矩陣A和B，用C語言編程實現兩個函數相加和相乘：

一、矩陣相乘。程序中先初始化矩陣，然後判斷第一個矩陣的列數和第二個矩陣的行數是否相等，如果不相等則直接提示錯誤後退出程序。相等的話則利用公式計算乘積，結果賦給matrix二維數組。最後用for循環列印出結果驗證。

#include<stdio.h>

#include<stdlib.h>

#define M 100

int main(void)

{

int i,j,k,matrix1[M][M],matrix2[M][M],row1,col1,row2,col2,matrix[M][M];

printf("輸入第一個矩陣的行數和列數：");

scanf("%d%d",&row1,&col1);

printf("輸入第一個矩陣： ");

for(i=0;i<row1;i++){

for(j=0;j<col1;j++){

scanf("%d",&matrix1[i][j]);

}

}

printf("輸入第二個矩陣的行數和列數：");

scanf("%d%d",&row2,&col2);

printf("輸入第二個矩陣： ");

for(i=0;i<row2;i++){

for(j=0;j<col2;j++){

scanf("%d",&matrix2[i][j]);

}}

for(i=0;i<row1;i++){

for(j=0;j<col2;j++){

matrix[i][j]=0;

} }

if(col1!=row2){

fprintf(stderr,"enput error!");

exit(EXIT_FAILURE);

}

printf("The result: ");

for(i=0;i<row1;i++){

for(j=0;j<col2;j++){

for(k=0;k<col1;k++){

matrix[i][j]=matrix[i][j]+matrix1[i][k]*matrix2[k][j];

} } }

for(i=0;i<row1;i++){

for(j=0;j<col2;j++){

printf("%d ",matrix[i][j]); }

printf(" "); }

return 0;}

二、矩陣相加：

#include<stdio.h>

#define M 20

#define N 20

float A[M][N];

float B[M][N];

float C[M][N];

int i,j,m,n,p,q;

float y=1.0;

void main()

{

scanf("%d,%d",&i,&j);

printf("請輸入矩陣B的行數和列數(用逗號隔開):");

scanf("%d,%d",&m,&n);

if(i!=m||j!=n)

printf("***對不起，您輸入的兩個矩陣不能相加，請重試.*** ");

else printf("請輸入矩陣A: ");

for(p=0;p<i;p++)

for(q=0;q<j;q++)

scanf("%f",&A[p][q]);

printf("輸出矩陣A： ");

for(p=0;p<i;p++)

for(q=0;q<j;q++)

{

printf("%10.2f",A[p][q]);

if((q+1)%j==0)

printf(" ");

}

printf("請輸入矩陣B： ");

for(p=0;p<i;p++)

for(q=0;q<j;q++)

scanf("%f",&B[p][q]);

printf("輸出矩陣B： ");

for(p=0;p<i;p++)

for(q=0;q<j;q++)

{

printf("%10.2f",B[p][q]);

if((q+1)%j==0)

printf(" ");

}

printf("矩陣A+矩陣B為: "); //計算兩個矩陣相加

for(p=0;p<i;p++)

for(q=0;q<j;q++)

C[p][q]=A[p][q]+B[p][q];

for(p=0;p<i;p++)

for(q=0;q<j;q++)

{

printf("%10.2f",C[p][q]);

if((q+1)%j==0)

printf(" ");

}

};

『貳』 OCaml 4.08.0 發布，函數式編程語言

OCaml（Objective Caml） 4.08.0 發布了。OCaml 是 Caml 編程語言的主要實現，Caml 是函數式編程語言，OCaml 將 Caml 語言在面向對舉塌象方面做了延展，它的擴展語言還有基於微軟 .net 平台的 F# (fsharp) 語言。Caml 的代碼大多可以在 F# 中使用。

此版本更新亮點包括：

綁定運算符（let*、let+、and* 等），它們可用於簡化一元代碼。

`open`現在適用於結構中的任意模塊表達式和簽名中的應用路徑。

（用戶定義的）「警報」的新概念概括了已棄用的警告。

標准庫中的新模塊：Fun、Bool、Int、Option、Result。

Float 中的大量新功能，包括 FMA 支持和新的 Float.Array 子模塊。

在批處理模式下突出顯示錯誤和警告鏈陸的來源。

許多錯誤消息得到了棚答頃改進。

改進了對象和惰性值的 AFL 檢測。

『叄』 為什麼要用函數式編程

以 C 語言源程序為例，使用函數式的編程風格主要是有利於程序的調試！而且程序的可讀性也很好。程序思路很清楚！！以下面的源程序進行講解就一目瞭然了。在以下題目中，三次用到了求階乘的代碼（A!、(A-B)!、B!），現在使用調用子函數的編程風格，程序簡潔明了、且可讀性很強。如果不使用函數式編程，那麼求階乘的代碼你就必須要重復三次。你說到底是哪一種編程風格好呢？
例如：求組合數C(A，B) = A!/( (A-B)! * B! )
int jie_cheng( int ) ;

void main( )

{
int a = 0,b = 0 , c = 0 ;

scanf("%d %d",&a,&b);

c = jie_cheng(a) / (jie_cheng(a-b)*jiecheng(b)) ;

printf("Zu he shu C is: %d\n", c);
}
int jie_cheng(int num)

{
if( num == 1)
return 1 ;
else
return num*jie_cheng(num-1) ;
}

『肆』 前端必學-函數式編程（六）

我們前篇談了很多關於【閉包】的理解了，所以你應該會知道，我們現在將要談的就是 ——【非同步】。

我們為什麼覺得「非同步問題」復雜呢？

其中很重要的一個原因是 —— 時間！時間將我們對數據的操判運作、管理，變復雜了好幾個量級！

（需要特別提出並明確的是： 非同步和同步之間是可以相互轉化的！ 我們使用非同步或者同步取決於 —— 如何使代碼更加可讀！）

函數式編程給出了實現「代碼更可讀」的落地原則（已多次回顧）：

所以我們可以期待，非同步在函數式編程中的表現！

上代碼：

onCustomer(..) 和 onOrders(..) 是兩個【回調函數】釋義，兩者執行的先後順序並不能確定，所以它是一個基於時間掘喚梁的復雜狀態。

釋義：回調函數其實就是一個參數，將這個函數作為參數傳到另一個函數裡面，當那個函數執行完之後，再執行傳進去的這個函數。

通常來說，我們最先想到的是：把 lookupOrders(..) 寫到 onCustomer(..) 裡面，那我們就可以確認 onOrders(..) 會在 onCustomer(..) 之後運行。

這樣寫，對嗎？

不對！因為 onCustomer(..) 、 onOrders(..) 這兩個回調函數的關系更像是一種競爭關系（都是賦值 customer.orders ）， 它們應該並行執行 ， 而不是串列執行 。

即：我不管你們誰先執行，誰先執行完，誰就賦值給 customer.orders ！

那我們的思路應該是：

不過，這樣讓代碼又變得更加難閱讀！！函數內部賦值依賴於外部變數、甚至受外部回調函數的影響。

那究竟怎麼辦呢？

最終，我們借用 JS promise 減少這個時間狀態，將非同步轉成同步：

兩個 .then(..) 運行之前， lookupCustomer(..) 和 lookupOrders(..) 已被同步調用，滿足並行執行，誰先結束，誰賦值給 customer.orders ，所以我們不需要知道誰先誰後！

在這樣的實現下，不再需要時間先後的概念！減少了時間狀態！！代碼的可讀性更高了！！

這是一個 積極的數組 ，因為它們同步（即時）地操作著離散的即時值或值的列表/結構上的值。

什麼意思？

a 映射到 b，再去修改 a ，b 不會收到影響。

而這，是一個 惰性的數組 ， mapLazy(..) 本質上 「監聽」 了數組 a，只要一個新的值添加到數組的末端（push(..)），它都會運行映射函數 v => v * 2 並把改變後的值添加到數組 b 里。

什麼意思？

a 映射到 b，再去修改 a ，b 也會修改。

原來，後者存在 非同步 的概念。

讓我們來想像這樣一個鏈櫻數組，它不只是簡單地獲得值，它還是一個懶惰地接受和響應（也就是「反應」）值的數組，比如：

設置「懶惰的數組」 a 的過程是非同步的！

b ，是 map 映射後的數組，但更重要的是，b 是 反應性 的，我們對 b 加了一個類似監聽器的東西。

這里直接給出解答：

這里再多小結一句：時間讓非同步更加復雜，函數式編程在非同步下的運用就是減少或直接幹掉時間狀態。

想像下 a 還可以被綁定上一些其他的事件上，比如說用戶的滑鼠點擊事件和鍵盤按鍵事件，服務端來的 websocket 消息等。

上述的 LazyArray 又可叫做 observable ！（當然，它不止用在 map 方法中）

現在已經有各種各樣的 Observables 的庫類，最出名的是 RxJS 和 Most 。

以 RxJS 為例：

不僅如此，RxJS 還定義了超過 100 個可以在有新值添加時才觸發的方法。就像數組一樣。每個 Observable 的方法都會返回一個新的 Observable，意味著他們是鏈式的。如果一個方法被調用，則它的返回值應該由輸入的 Observable 去返回，然後觸發到輸出的 Observable里，否則拋棄。

比如：

本篇介紹了【非同步】在函數式編程中的表現。

原則是：對於那些非同步中有時態的操作，基礎的函數式編程原理就是將它們變為無時態的應用。即 減少時間狀態 ！

就像 promise 創建了一個單一的未來值，我們可以創建一個積極的列表的值來代替像惰性的observable（事件）流的值。

我們介紹了 RxJS 庫，後續我們還會介紹更多優美的 JS 函數式編程庫！

（俗話說的好，三方庫選的好，下班都很早！！）

現在本瓜有點明白那句話了：看一門語言是不是函數式編程，取決於它的核心庫是不是函數式編程。

也許我們還不熟悉像 RxJS 這類庫，但我們慢慢就會越來越重視它們，越來越使用它們，越來越領會到它們！！

非同步，以上。

『伍』 什麼是函數式編程思維

回答都有跑題，show概念之嫌，題主問的是函數式思維，這個問題我一直在思考，畢竟是方法論，能力有限，只能從切身實踐告訴你
1.表達式化
在
最初的時候，需要轉變觀念，去可變數，去循環，把命令式改成表達式，注意，這只是把你丟在荒山野嶺讓你感受一下，離開熟悉的環境，地球依然在轉，但是有個
重點，那就是一切都是表達式; 為什麼是表達式呢？這個問題就像為什麼魚在水裡?
因為函數式建立在lambda演算之上而非圖靈機，只不過兩者被證明等價，所以你可以在你的機器上跑全是表達式的代碼，就如有人證明天空適合魚生存，所以
魚可以在天上游
當你接受了魚可以在天上游之後，就該上正餐了

1.5 數據與行為分離
這也是和面向對象不一致的地方，面向對象強調數據與行為綁定，但函數式不是，確切的說函數式 函數與數據等價，所以你才可以將函數當參數與返回值，你在設計時，切勿讓數據自己長腿能跑，其次，行為必須消除副作用，不可以偷偷把數據改了，習慣第一條後，應嘩虧耐該不會的

2.高階邏輯
用
了函數式，就不要在想循環，賦值這些低階邏輯了，而應該更高階的思考問題，這比轉化表達式更難，函數式又叫聲明式，也就是你要做什麼，只要說一下就行，而
非寫個遍歷，做個狀態判斷，空棗用函數式你不需要考慮這些，你不知道函數式的列表是怎麼遍歷的，中間向兩邊?
從後往前?這也是為何函數式適合並發的原因之一，你想知道列表中大於3的數有多少，只要，list.count(_ > 3)
而不是寫循環，你可以直接寫你的業務，不要拘泥於細節，有點像sql, 你需要什麼告訴電腦就行，你或許會問，count foreach filter
這些函數怎麼來的? 因為有了他們你才不需要寫循環，他們把你留在高階邏輯中亂春，這個問題的答案請看下面

3.組合子邏輯 或又叫 自底向上的設計
函
數式和OO是反的，面向對象是自頂向下的設計，函數式是自底向上的設計，也就是先定義最基本的操作，然後不斷組合，不斷堆積以滿足你的所有需要，如sql
定義了select, from, where...這幾個組合子，來滿足你的查詢需求，同理函數式語言會提供foreach,
map等組合子(操作)來滿足你的需求，所以你必須自下而上的設計你的代碼結構，並且滿足你的需求，當你只用組合子寫代碼時，你會發現你寫的全是高階邏輯
如
果這些已有組合子滿足不了你，你就得自己寫，foreach不行，你就自己寫遞歸，我告訴你，遞歸背後也是組合子，這里一些'大神'應該不知道，在圖靈機
里，遞歸就是方法不斷調用自己沒什麼好說的，但是在lambda演算中，匿名函數是沒法調用自己的，所以遞歸是用Y組合子(又叫不動點組合子)把遞歸函數
自己求解出來再調用的，這才可以實現遞歸，並與圖靈機的循環等價，有點跑題了，總之要想順手的寫函數式，最好用面向組合子的設計，注意，不是必須，組合子
演算和lambda演算可以相互轉化，也就是，你完全可以寫一堆雜亂的表達式，但沒有組合子邏輯來得清爽，Haskell大規模使用monad這個特殊組
合子，始其變得統一整潔

好了，總結一下
函數式思維，其實就是組合子邏輯，用簡單的幾個函數組合來構建復雜邏輯，始終以高階的角度去表達問題，而非依賴副作用。
知道這點，你用java也可以寫函數式代碼了

但是，這也只是本人積累得來的感悟，絕不敢大肆伸張這就是函數式，我也在不斷研究中，如有問題，還望大神指正

『陸』 JS函數式編程和遞歸探索：路由樹的操作

開始切入正題之前，有必要告知大家一下，這篇文章可能有一些深度，初學者可能理解會有些吃力。我會盡量把復雜問題簡單化，爭取讓每個閱讀的童鞋們都能看得懂。希望你對element-ui，vue-router，KeepAlive組件有一點了解。現在，我們開始吧液態碧。

熟悉element-ui的童鞋們都知道，ElMenuItem和ElSubMenu都需要一個鬧舉index屬性，該屬性必須是唯一的。現在，我們想把路由配置直接應用於ElMenu，該如何確保index的唯一性呢？我們需要有一個生成唯一index的函數。如下是genKey函數的定義，是不是很簡單？

現在，我們創建addRouteMetaKey函數，該函數對路由樹進行遞歸遍歷，為每一個路由配置的meta屬性動態添加key欄位。這個函數很簡單，屬於最基礎的遞歸使用例子，我就不做太多解釋了。

提示 ：數組的forEach方法不是純函數，因為它有副作用，所以forEach方法不能稱之為函數式編程工具。

通過addRouteMetaKey函數，我們可以把路由的meta.key作為index的值了。

現在，我們想實現另一個功能，就是 基於標簽頁的路由組件緩存控制 。使用過Vuejs KeepAlive組件的童鞋們，應該多多少少都遇到一些坑吧？在我們的項目中，有一個頂部標簽頁導航，每個tab項對應一個url，以每個url對應路由的title作為tab項標題，當切換tab的時候載入緩存中的url對應的路由組件，關閉tab項，下次打開該路由url，重新掛載對應的路由組件，而不是從緩存中載入。

當路由層級不確定的時候，KeepAlive會變的難以手動控制。所以，我 劍走偏鋒，嘗試了一種簡單的解決方案 ，實踐證明： 這是非常有效的 。我的方案就是把無限層級的路由樹轉化為一維數組。通過為meta添加必要的欄位，進行頁面結構個性化定製。

我們需要把每層路由配置的path轉化為全路徑，所以需要一個函數：getRouteFullPath，該函數定義如下：

getRouteFullPath函數中使用到的joinPath函數用於將多個路徑字元串拼接為1個完整的路徑，定義如下：

現在，我們把路由樹轉化為一維數組。我們定義toFlatRoutes函數，該函數使用了數組的rece方法對路由樹進行聚合遞歸，將路由配置中的path屬性的值替換為全路徑，還順便給路由配置添加了name屬性，返回一個新的一維路由配置數組。 這是函數式編程和遞歸結合的一個例子。

以上，我們解決了KeepAlive的緩存控制問題；現在，我們又有了一個新的用戶體驗上的需求，就是我們想根據url對應的路由，自動展開該路由meta.key所屬的側邊菜單；我們通過查閱element-ui文檔得知，ElMenu有一個open方法，接收index作為參數，展開index對應的菜單。

現在的問題是，我們的路由對應的index是ElMenuItem的，而路由樹已經被我們轉化為了一維數組，通過路由的matched欄位是得不到我們想要的菜單index的。所以， 我們需要遍歷原始路由樹 。

如下代碼，我們定義getMenuKey函數，該函數接收的參數為route對象。如果路由存在，我們進行查找。首先進行簡單查找，如果找到一個菜單menu，閉大則返回該菜單的meta.key；如果簡單查找無果，則對路由樹進行遞歸查找； 這是函數式編程和遞歸結合的另一個例子。

現在，我們大功告成了；以上就是本節的知識點，童鞋們理解了嗎？只要我們熟悉遞歸的使用，其實操作樹很簡單。如果大家還有不懂的，可以評論區問我。感謝閱讀！

『柒』 Scala語言的主要應用領域與作用

Scala的特性
1.面向對象特性
Scala是一種純面向對象的語言，每一個值都是對象。對象的數據類型以及行為由類和特徵（Trait）描述。類抽象機制的擴展有兩種途徑。一種途徑是子類繼承，另一種途徑是靈活的混入（Mixin）機制。這兩種途徑能避免多重繼承的種種問題。

2.函數式編程
Scala也是一種函數式語言，其函數也能當成值來使用。Scala提供了輕量級的語法用以定義匿名函數，支持高階函數，允許嵌套多層函數，並支持柯里化。Scala的CaseClass及其內置的模式匹配相當於函數式編程語言中常用的代數類型（AlgebraicType）。

更進一步，程序員可以利用Scala的模式匹配，編寫類似正則表達式的代碼處理XML數據。在這些情形中，順序容器的推導式（comprehension）功能對編寫公式化查詢非常有用。

由於JVM不支持尾部遞歸，Scala也不能完全支持尾部遞歸優化。不過，在簡單的情況下，Scala編譯器可以把尾部遞歸優化成循環。

4.靜態類型
Scala是具備類型系統，通過編譯時的檢查，保證代碼的安全性和一致性。類型系統具體支持以下特性：

泛型類，型變注釋（VarianceAnnotation），類型繼承結構的上限和下限，把類別和抽象類型作為對象成員，復合類型，引用自己時顯式指定類型，視圖，多態方法。

5.擴展性
Scala的設計承認一個事實，即在實踐中，某個領域特定的應用程序開發往往需要特定於該領域的語言擴展。Scala提供了許多獨特的語言機制，可以以庫的形式輕易無縫添加新的語言結構：

任何方法可用作前綴或後綴操作符，可以根據預期類型自動構造閉包。聯合使用以上兩個特性，使你可以定義新的語句而無須擴展語法也無須使用宏之類的元編程特性。

5.使用Scala的框架
Lift是一個開源的Web應用框架，旨在提供類似RubyonRails的東西。因為Lift使用了Scala，所以Lift應用程序可以使用所有的Java庫和Web容器。

scala語言主要應用領域
cala運行於JVM之上，並且它可以訪問任何的java類庫並且與java框架進行互操作，scala也大量重用了java類型和類庫。

大數據的開發語言是Scala的原因：

1：大數據的本身是計算數據，而Scala即有面向對象組織項目工程的能力，又有計算數據的功能。

2：現在大數據事實上的計算標准框架Spark，它是用Scala開發的，因為計算數據，Scala它是函數式編程，它實現演算法非常簡潔優雅。

例：kafka，它是一個消息中間件，如果外部數據要流進大數據中心，我們一般都要用kafka作適配器，那如果大數據中心的數據流到外部，也是用kafka（如Spark計算的數據要交給HBASE或MySql，期間我們都會用kafka），很多的大數據組件都是用的Scala編寫的，所以，如果你想成為一個較高級的大數據開發高手，你一定要掌握Scala。

『捌』 闡述函數編程的最新發展動態是什麼

• 函數式編程語言的興沖激渣起：隨著函數式編程範式的流行，越來越多的函數式編程語言被開發和應用，例如Clojure、Scala、Haskell等。這些語言具有高度的抽象和表達能力，能夠提高程序的可讀性和可維護性。

• 函數式編程的並行化：由於函數式編程強調函鉛數數之間的獨立性和無狀態性，因此函數式編程非常適合並行化處理。近年來，越來越多的函數式編程框架和庫被開發出來，能夠方便地實現並行化處理，提高程序的性能和效率。

• 函數式編程與人工智慧的結合：函數式編程的特點使其非常適合處理人工智慧領域的問題。近年來，越來越多的人工智慧工具和庫開始採用函數式編程的範式，例如TensorFlow、PyTorch等。

• 函數式編程與大數據的結合：函數式編程對數據的處理非常方便，因此在大數據領域中也受到越來越多的關注。例如，Spark和Flink等大數據框架中採用了函數式編程的思想，提高了程序的可讀性和可維護性。

• 函數式編程與區塊鏈的結合：區塊鏈是一個去中心化的分布式賬本系統，其中智能合約是一個重要的功能。智能合約通常使用函數式散悄編程語言進行編寫，例如Solidity語言，以確保合約的安全和正確性。

『玖』 函數在編程中扮演著什麼樣的作用

函數在編程中的作用：
支持閉包和高階函數，支持惰性計算（lazy evaluation）。使用遞歸作為控制流程的機制。加強了引用透明性。沒有副作用。我將重點放在在 Java 語言中使用閉包和高階函數上，但是首先對上面列出的所有特點做一個概述。

閉包和高階函數
函數編程支持函數作為第一類對象，有時稱為 閉包或者 仿函數（functor）對象。實質上，閉包是起函數的作用並可以像對象一樣操作的對象。與此類似，FP 語言支持 高階函數。高階函數可以用另一個函數（間接地，用一個表達式） 作為其輸入參數，在某些情況下，它甚至返回一個函數作為其輸出參數。這兩種結構結合在一起使得可以用優雅的方式進行模塊化編程，這是使用 FP 的最大好處。

惰性計算
除了高階函數和仿函數（或閉包）的概念，FP 還引入了惰性計算的概念。在惰性計算中，表達式不是在綁定到變數時立即計算，而是在求值程序需要產生表達式的值時進行計算。延遲的計算使您可以編寫可能潛在地生成無窮輸出的函數。因為不會計算多於程序的其餘部分所需要的值，所以不需要擔心由無窮計算所導致的 out-of-memory 錯誤。一個惰性計算的例子是生成無窮 Fibonacci 列表的函數，但是對 第 n 個Fibonacci 數的計算相當於只是從可能的無窮列表中提取一項。

遞歸
FP 還有一個特點是用遞歸做為控制流程的機制。例如，Lisp 處理的列表定義為在頭元素後面有子列表，這種表示法使得它自己自然地對更小的子列表不斷遞歸。

函數的優點:

1.代碼簡潔，開發快速
函數式編程大量使用函數，減少了代碼的重復，因此程序比較短，開發速度較快。
Paul Graham在《黑客與畫家》一書中寫道：同樣功能的程序，極端情況下，Lisp代碼的長度可能是C代碼的二十分之一。
如果程序員每天所寫的代碼行數基本相同，這就意味著，"C語言需要一年時間完成開發某個功能，Lisp語言只需要不到三星期。反過來說，如果某個新功能，Lisp語言完成開發需要三個月，C語言需要寫五年。"當然，這樣的對比故意誇大了差異，但是"在一個高度競爭的市場中，即使開發速度只相差兩三倍，也足以使得你永遠處在落後的位置。"

2. 接近自然語言，易於理解
函數式編程的自由度很高，可以寫出很接近自然語言的代碼。
前文曾經將表達式(1 + 2) * 3 - 4，寫成函數式語言：
subtract(multiply(add(1,2), 3), 4)
對它進行變形，不難得到另一種寫法：
add(1,2).multiply(3).subtract(4)
這基本就是自然語言的表達了。再看下面的代碼，大家應該一眼就能明白它老戚哪的意思吧：
merge([1,2],[3,4]).sort().search("2")
因此，函數式編程的代碼更容易理解。
3. 更方便的代碼管理
函數式編程不依賴、也不會改變外界的狀態，只要給定輸入參數，返回的結果必定相同。因此，每一個函數都可以被看做獨立單元，很有利於進行單元測試（unit testing）和除錯（debugging），以及模塊化組合。

4. 易於"並發編程"
函數式編程不需要考慮"死鎖"（deadlock），因為它不修改變數，所以根本不存在"鎖"線程的問題。不必擔心一個線程的數據，被另一個線程修改，所以侍碼可以很放心地把工作分攤到多個線程，部署"並發編程"仔棗（concurrency）。
請看下面的代碼：
var s1 = Op1();
var s2 = Op2();
var s3 = concat(s1, s2);
由於s1和s2互不幹擾，不會修改變數，誰先執行是無所謂的，所以可以放心地增加線程，把它們分配在兩個線程上完成。其他類型的語言就做不到這一點，因為s1可能會修改系統狀態，而s2可能會用到這些狀態，所以必須保證s2在s1之後運行，自然也就不能部署到其他線程上了。
多核CPU是將來的潮流，所以函數式編程的這個特性非常重要。

5. 代碼的熱升級
函數式編程沒有副作用，只要保證介面不變，內部實現是外部無關的。所以，可以在運行狀態下直接升級代碼，不需要重啟，也不需要停機。Erlang語言早就證明了這一點，它是瑞典愛立信公司為了管理電話系統而開發的，電話系統的升級當然是不能停機的。