實用函數(shù)編程序列表達式和選擇工作流

1、F# LINQ F# 在（sequence# .NET 中表達同樣概念的是：IEnumerable在.NET 框架中有IEnumerable 類型的主要原因，是它提供一F# F# C# 中，F(xiàn)# F# LINQ F# 在（sequence# .NET 中表達同樣概念的是：IEnumerable在.NET 框架中有IEnumerable 類型的主要原因，是它提供一F# F# C# 中，F(xiàn)# 可以使用迭代來生成序列，用 LINQ 查詢?nèi)ヌ幤饋?，用序列表達式（sequence expresF中，序列表達式的語法并不是專為處理序列而設計的、單一用途的語言功能；它正是一個（） 更通用的結(jié)構(gòu)的應用，稱為計

2、算表達式（compu ionexpres 。計F#.NET LINQtoSQL （FC# 12.1 IEnumerator Current MoveNext ，把可變性隱藏到Lazy 類型中，把可變性隱藏到Lazy 類型中，可以使用高階函數(shù)。F# 庫提供了不少的函數(shù)處理序列，但會看到，C# F# C# 們可以使用迭代，F(xiàn)# 提供了通用目的的序列處理功能，稱為序列表達式（sequence 12.1.1 F# 中，處理序列的函數(shù)在 Seq fole 函數(shù)是一對，它的參數(shù)為集合，把集合“折疊”成一個值；unfold 的參0 10 的數(shù)字：letnums=Seq.unfold(funnumif(num

3、=10)thenSome(string(num),num+1)else None)valnums:seq=seq0;1;2;3;num lambda 函數(shù)時，num 的值設置Lambda Some lambda IEnumerable F# 型別名。同樣的類型可以有不同方式，同樣，float System.Single C# 以F# .NET C# C# 中，很少的幾個方法之一，是生成序列Enumerable.Range（System.Linq 命名空間(二個參數(shù)（第一個參數(shù)C# Seq.unfold 但C# 在C# 當 2.0 IEnumerable # 12.1 12.1 factoria

4、l=num=0;factorial1000000;num+)factorial=factorial*yieldreturnString.Format(01num- C# IEnumerable 接口的“隱藏”12.1 為 factorial=num=0;factorial1000000;num+)factorial=factorial*yieldreturnString.Format(01num- C# IEnumerable 接口的“隱藏”12.1 為 for F# 12.1.3 F# # （comfortable# C# yield return 表示（yield break 表示終止序列

5、 yieldreturn C# # 12.2 12.2 let numsseq letn=yieldn+fnyieldn+2valnums:F# seq 塊中1seq 1seq 塊，把整個表達C# 相類似，有從序列中返回元素的語F# yield 關鍵字2F# 結(jié)構(gòu)，比如值綁定，foreach F# 示例，yield C# List.ofSeq Fseq 1seq 塊，把整個表達C# 相類似，有從序列中返回元素的語F# yield 關鍵字2F# 結(jié)構(gòu)，比如值綁定，foreach F# 示例，yield C# List.ofSeq F# nums|valitlist=11;fn

6、yield nums|Seq.take1|valitlist=Seq 模塊中的一個序列處理函數(shù)，它只從序列中取一個元素。take 1，表，就得到只包含一個元素的列表，但不調(diào)用 prfn 函數(shù)。F# 當-1 seq 甚至可以自己定義F# 語言中內(nèi)置的、專門關鍵字。seq seq seq C# 中，yield return C# 在函數(shù)式編程中，可組合性ability）是一個更重要的概念，所以，F(xiàn)# 通常發(fā)音 bang12.3 12.3 letcapitalsParisPrague- valcapitals:stringletwithNew(name)12.3 12.3 letc

7、apitalsParisPrague- valcapitals:stringletwithNew(name)seqlet allCitiesseq yield Osloyield! capitals valallCities:allCities|valit:stringlist=Oslo;Paris;Prague;York;New- 12.3 首先創(chuàng)建兩種不同的數(shù)據(jù)源。第一個是 F# 列表，有兩個首都，值的類型是 listF# seqa 接口，因此，在后面的代碼中能夠?qū)⑺斪餍蛄袀€數(shù)據(jù)源聯(lián)接成一個序列。首先，使用 yield 語句返回一個值1；接著，使用 yield! 結(jié)構(gòu)返回 F# 列表中的

8、所有元素2；最后，調(diào)用 withNew 函數(shù)3（返回一個序列，返回序列yield 一樣，yield! 結(jié)構(gòu)也是延遲返回元素。就是說，當代碼到達調(diào)用 withNew 12.2 F# F# F# 12.2.1 letrec 用于組合序列的 yield! 的 C# 示例一樣。12.4 1 12.4 使用序列表達式生成序列數(shù)letrecfactorialsUtil(num,factorial)seqif(factorialletrecfactorialsUtil(num,factorial)seqif(factorial letfactorials=factorialsUtil(0,valfactor

9、ials:seqseq0!=1;1!=1;2!=2;3!=6;4!=2412.4 1列4。這里是 0，因為根據(jù)定義，0 的階乘是 1。seq 查最后的階乘是否小于 1 百萬，如果為否，就終止序列；省略了 if 表達式的 ele 分支，所以，不會產(chǎn)生任何額外的數(shù)字。如果條件為值，首先產(chǎn)生一個結(jié)果2，它表示下一個階乘被格式化為字符串。接下來，遞增這個數(shù)，并執(zhí)行遞歸調(diào)用。這將返回從下一個數(shù)字yield! 注意，因為 C# 沒有對應于 yield! 的功能，所以，要將這種方法轉(zhuǎn)換為 C# 用到大量的嵌套循環(huán)，效率也很低。在 F# 中，針對使用 yield! 尾遞歸進行了優(yōu)化，類似于常規(guī)函數(shù)調(diào)用。這樣，

10、當序列表達式以 yield! 調(diào)用結(jié)尾，并且沒有后續(xù)的代碼（yield! F# 用單元）while很多時候不需要它們。相反，for seq seq 類型的延遲序列，對應于標準的F# .NET IEnumerable 類型。F# letcities yield yield!capitalsvalcities:stringlistOslo;London;Prague letcities |yieldBarcelona yield!capitalsvalcities:stringarray F# letcities yield yield!capitalsvalcities:stringlistOs

11、lo;London;Prague letcities |yieldBarcelona yield!capitalsvalcities:stringarray F# 當則if 條件）F# 是12.2.2 在 列可能是無窮的，即，MoveNext 不會返回 12.5 12.5 C# F# /C#using varrnd=new r=rnd.Next(256),g=rnd.Next(256),b=/F# usingletrnd=newletrecrandomColors=seqletr,g,b=rnd.Next(256),rnd.Next(256), 兩個實現(xiàn)都包含生成顏色的無限循環(huán)。在C# 中，循

12、環(huán)使用while(true) 實現(xiàn)1；函數(shù)式方法創(chuàng)建無限循環(huán)是使用遞歸5。在無限循環(huán)的主體中產(chǎn)生一個隨機生成的顏色值在 F# 中使用yield 結(jié)構(gòu)4，在letrnd=newletrecrandomColors=seqletr,g,b=rnd.Next(256),rnd.Next(256), 兩個實現(xiàn)都包含生成顏色的無限循環(huán)。在C# 中，循環(huán)使用while(true) 實現(xiàn)1；函數(shù)式方法創(chuàng)建無限循環(huán)是使用遞歸5。在無限循環(huán)的主體中產(chǎn)生一個隨機生成的顏色值在 F# 中使用yield 結(jié)構(gòu)4，在C# 中yieldreturn2# 12.5 在把 F# seq 塊中的時候，使用了不同的縮進樣式3se

13、q 選12.6 F# 代碼，C# 版本（非常類似）12.6 (F#) open System.DrawingopenletdataSource=490;485;450;425;365;340;290;230; 130;90;70;letcoloredSequence=Seq.zipdataSourceletcoloredData=coloredSequence|letfrm=newForm(C ntSize=Size(500,.Add(funerushes.White,0,0,500,coloredData|Seq.iteri(funi(num,clr)usebr=newr0i*32num28

14、- ) 生成的顏色組合起來1101 是什么意思？Seq.iteri 函數(shù)3（又出現(xiàn)這個字了。是正常的意思嗎？）實現(xiàn)它，顏色在繪圖函數(shù)中計算3 單 12.7 顯示另一種配色方案。12.7 (Cand/C#using 是什么意思？Seq.iteri 函數(shù)3（又出現(xiàn)這個字了。是正常的意思嗎？）實現(xiàn)它，顏色在繪圖函數(shù)中計算3 單 12.7 顯示另一種配色方案。12.7 (Cand/C#using g=0;g255;g +=yieldreturnColor.FromArgb(g/2,g,g/F# usingloopandletrecgreenBlackColors=seqin0.25.255yieldC

15、olor.FromArgb(g/2,g,g/yield!greenBlackColors在 12.7 中的代碼再次包含了無限循環(huán)，使用 while 循環(huán)1和遞歸3生成了漸變顏色，包含 10 使用 for # 法2。g 的值從 0 開始，每次迭代增加 25，直到值大于 250 為止。圖 12.1 顯示了最終12.1 Haskell F# F# Lazy Haskell let nums=1: 12.1 Haskell F# F# Lazy Haskell let nums=1: n+1|nSeq.cache 1000 100 Haskell F# 慣用的解決方案，通常是更好的主意，比如，這里使用

16、的 yield!。12.3 C# （IEnumerable 接口（iteratorblocks，自己的）Where Select，如果只處理涉及某些特定 C# 3.0 的查詢語法。F# 如，List.filter List.map Array Seq 模塊中，同樣有處理序列的函數(shù)集，一點也不奇怪。F# 12.3.1 numbers)C# （IEnumerable 接口（iteratorblocks，自己的）Where Select，如果只處理涉及某些特定 C# 3.0 的查詢語法。F# 如，List.filter List.map Array Seq 模塊中，同樣有處理序列的函數(shù)集，一點也不奇

17、怪。F# 12.3.1 numbers)iinyieldreturni*使用的是熟悉的 foreach 結(jié)構(gòu)，但是要記住，包含 yield return 語句的 foreach，有了 不同的含義，它不會提前進行循環(huán)，而是在需要時才計算。foreach 語句，為每次循環(huán)迭代 （pulling輸出序列始終只生成一個元素LINQtoObjects Where Select 想實現(xiàn) Zip 方法，與 F# 中的 Seq.zip .NET 4.0 要foreach 和 IEnumerator 接口。 12.8 Zip public ,IEnumerablesecond)En| while yieldre

18、turn C# Tuple 首先獲得每個序列能夠進行遍歷元素的枚舉器1MoveNext 方法，從兩個序列中獲得下一個元素2。如果有一個序列已經(jīng)結(jié)束，IEnumerator 接口。foreach 要在 F# Seq.zipwhile .NET F# C# 12.3.2 C# Tuple 首先獲得每個序列能夠進行遍歷元素的枚舉器1MoveNext 方法，從兩個序列中獲得下一個元素2。如果有一個序列已經(jīng)結(jié)束，IEnumerator 接口。foreach 要在 F# Seq.zipwhile .NET F# C# 12.3.2 pojctionSelect F# C# .NETList 類型。LINQ

19、 Where F# Seq （Seq.map Sqiler， F# Seq List C# LINQ varnums1nums.Where(n=n%3=.Select(n=n*letnums1nums|Seq.filter(funn-|Seq.map(funn-n*當 10 C# 3.0 F# F# # 12.9 C# F# 12.9 C# F# # # # for 循環(huán)取代，where if 條件取代，select yield # # 12.9 C# F# 12.9 C# F# # # # for 循環(huán)取代，where if 條件取代，select yiel

20、d # # # F# 。F# C# 的運行。C# lambda 效的就行。這個“數(shù)據(jù)源不可知論（datasourceagnosticism）LINQtoObjects LINQto，yield # LINQ C3.0 # varqfromcincustomers orderbyc.Nameselectlet q |Seq.sortBy(func-Seq.sortBy 哪個屬性。在 C# orderby 子句后的表達式；C# lambda OrderBy 方法的調(diào)用。F# varqlet q var nums1 = fromninnumswheren%3=0 select n * n;let n

21、ums1 = seq forninnumsif(n%3=0)then yield n * n fromc ingroupc by|Seq.groupBy(func- F# 使用標準的lambda 寫F# 的代碼，需要操作C# F# C# fromc ingroupc by|Seq.groupBy(func- F# 使用標準的lambda 寫F# 的代碼，需要操作C# F# C# C#F# 中轉(zhuǎn)換是如何運行的。 rojction12.3.3 在 LINQ 庫中，這個操作稱為 SelectManyfrom Select 操作，但是能夠為源中的每個項目返回多個元素。F# 庫中Seq.collectS

22、eq.map 函數(shù)，生成序列的序列，然后，調(diào)用 Seq.concat，將它們串聯(lián)起來。一樣先看一下用F# 序列表達式的實現(xiàn)，然后，再逐步修改代碼，使。 letcities=(NewYork,USA);(London,(Cambridge,UK);(Cambridge,USA) let entered = London; Cambridge 可以在 cities 列表中遍歷所選的城市，找到Cambridge 在序列表達式中使用兩個嵌套的 for 循環(huán)。12.10 12.10 seqfornameinenteredfor(n,c)incitiesif(n=name)|yieldf%

23、s(%s)nc| valit:seqseqLondon(UKCambridge(UKseqfornameinenteredfor(n,c)incitiesif(n=name)|yieldf%s(%s)nc| valit:seqseqLondon(UKCambridge(UKCambridge(USA| for entered 中的名字1cities 列表2，果名字相同的話，嵌套在兩個循環(huán)內(nèi)的代碼3使用 yield 語句，生成一個項目；如果名字F# 中聯(lián)接編程的首選方式。Seq.collect 12.2 Seq.map（）和 Seq.collect（）12.2 一定是 seq

24、類型。# # 用實現(xiàn)了 seq 可以返回序列，或者 F# Seq.collect Seq.collect for F# 12.11 12.11 entered|Seq.collect(funnameseqfor(n,c)incitiesif(n=name)yieldf%s(%s)ncvalit:seqseqLondon(UK);Cambridge(UK);Cambridge(USA)12.11 Seq.collect，用戶輸入的城市列表作 Lambda entered|Seq.collect(funnameseqfor(n,c)incitiesif(n=name)yieldf%s(%s)ncv

25、alit:seqseqLondon(UK);Cambridge(UK);Cambridge(USA)12.11 Seq.collect，用戶輸入的城市列表作 Lambda 12.10 lambda 12.12 替換循環(huán)entered|Seq.collect(funnamecities|Seq.collect(fun(n,c)if(n=name)f%s(%s)ncelse ); valit:seq=|seqLondon(UK);Cambridge(UK);Cambridge(USA)外層調(diào)用與12.11 中的相同，但是，在 lambda 函數(shù)，現(xiàn)在執(zhí)行另一個 yield 的使用。如果代碼包含多個

26、 yieldelse Seq.collect F# 和篩選實現(xiàn)嵌套循環(huán)2表達式中的 for 循環(huán)，足以表達實、篩選和聯(lián)接C# C# collect LINQ SelectManyLINQ 不同的要求。而 F# 序列表達式只能使用 collect 函數(shù)表示，LINQ 的 F# 12.13 CityInfo 類的實例，有兩個屬性，LINQ 12.13 varqfromeinfrom known in cities whereknown.City=e| （entered1 cities 2不同的要求。而 F# 序列表達式只能使用 collect 函數(shù)表示，LINQ 的 F# 12.

27、13 CityInfo 類的實例，有兩個屬性，LINQ 12.13 varqfromeinfrom known in cities whereknown.City=e| （entered1 cities 2，C# jion 子句，直接指定兩個數(shù)據(jù)源的鍵（e known.City 值join from from SelectMany 的調(diào)用。由 C# 編譯器執(zhí)行的轉(zhuǎn)換。12.14 12.14 (C#) var q = enterede =(e,known)=newe,known .Select(tmp = String.Format(0 (1), | |F # 中，if for 循環(huán)中（C# 和

28、 Select 執(zhí)行。lambda 函數(shù)1collect 而沒有任何篩選，或進一步地處理。第二個參數(shù)2F# ）C# ，from from select，都只能加到最后，處理聯(lián)接好的數(shù)據(jù)源。這不同于 F# 轉(zhuǎn)換，因為在 F# 和Seq.collect# 12.4 可選工作流（alternative計算表達式ion s）是一種F# 功能，部分靈感是來Haskell （brain-bustingly，from from select，都只能加到最后，處理聯(lián)接好的數(shù)據(jù)源。這不同于 F# 轉(zhuǎn)換，因為在 F# 和Seq.collect# 12.4 可選工作流（alternative計算表達式ion s）是

29、一種F# 功能，部分靈感是來Haskell （brain-bustingly Option F# 實現(xiàn)一組重要的方法，可以在 C# F# # 就可能使用過它們：LINQ 6.7 # LINQ Option.bind:(a-option)-option-List.collect:(a-list)-list-Seq.collect:(a-#seq)-seq-a執(zhí)行一次，且在第二個參數(shù)值是 Some 12.4.1 在把查詢表達式轉(zhuǎn)換為標準的函數(shù)調(diào)用，由 C# 編譯器所使用。為 12.6 節(jié)中的 12.15 整數(shù)列表（類型為List 函返回選項值（類型為12.15 varlistfromninfrom

30、minRead select n * m;12.15 整數(shù)列表（類型為List 函返回選項值（類型為12.15 varlistfromninfromminRead select n * m;varoptionfrom n fromselectn * 者都讀不同的輸入，并返回輸入整數(shù)的積。表 12.1 給出了樣本輸入和結(jié)果。12.1 對于列表，查詢執(zhí)行交叉聯(lián)接運算（F# for 循環(huán)Some NoneNone當?shù)谝粋€輸入為 None 時，12.15 在面F# 12.4.2 F# 所seq 括號中。然而，F(xiàn)# 還允許ions# 已經(jīng)知道，計算表達式可以包含標準的語言結(jié)構(gòu)，比如 for yield。

31、在代碼塊之前的標識符，描述構(gòu)造的意義，其方式與查詢運算符（例如，Select Where 擴展方法）LINQ TypeofInputInput2;10;Not20;200;30;for 結(jié)構(gòu)處理選項值，但是，F(xiàn)# 12.16 12.16 / optionforfor ()for()yieldn* / let! optionlet!n =let!m=tryRead return n * m，所有自定義的基本操作（例如，for、yield let!）for 結(jié)構(gòu)處理選項值，但是，F(xiàn)# 12.16 12.16 / optionforfor ()for()yieldn* / let! optionle

32、t!n =let!m=tryRead return n * m，所有自定義的基本操作（例如，for、yield let!）seq 12.5 12.16 12.15 LINQ for 集合，而是不處理選項值，而結(jié)構(gòu) for 和 yield 本操作，第一個是 let!，表示自定義的值綁定。n m 的類型是整數(shù)，自定義的值綁定從類型 option的值中取返回的值為None 時，它可能無法把值分配給符號，這樣，是return，描述了如何從值構(gòu)建選項值。在的結(jié)果類型是 option12.16 # # Haskell 中非常有用。F# # M type看到的 option，給代碼增加了返回未定義值（Non

33、e）seqa ）是由兩個函數(shù)，bind return，實現(xiàn)的。bind 12.16 使用 let! bind 操作。return let! for 12.16 了兩者密切相關。序列的 return ，M type看到的 option，給代碼增加了返回未定義值（None）seqa ）是由兩個函數(shù)，bind return，實現(xiàn)的。bind 12.16 使用 let! bind 操作。return let! for 12.16 了兩者密切相關。序列的 return ，yield C# F# bindreturn 12.5 在這個示例中，計算的類型（Haskell 是T C# F# （來增加功能12.

34、17 C# FC# F# 12.17C# F# C# publicValueWrapper(Tvalue) this.Value = value;publicTValueget;privateset;F# |ValueofC# 了類型 T 的值1F# 用模式匹配（Value 識別器）12.5.2 C# # T回這種計算類型的基本操作， 再使用這些基本操作實現(xiàn)其他的一切。然而， 構(gòu)建ValueWrapperT C# ()numreturnnew用模式匹配（Value 識別器）12.5.2 C# # T回這種計算類型的基本操作， 再使用這些基本操作實現(xiàn)其他的一切。然而， 構(gòu)建ValueWrappe

35、rT C# ()numreturnnewValueWrapperT F# returnF# 中表示為計算表達式（12.5.3 節(jié)C# 的擴展方法（12.5.4 節(jié)）IEnumerable 12.18 12.18 C# F# C# from 子句提取值1F# C# select 子句3F# varvfrom n in Read|1 from m in Readletadd=n+m let sub=n selectadd* valuelet! n = read|2 let! m = readletadd=n+m let sub=n returnadd*subreturn 基本操作4可以發(fā)現(xiàn)，C#

36、F# C# F# let # C# 中的查實現(xiàn)了 計算表達式之后，再回到 C#。12.18 bind 基本操作return 用于把結(jié)果打包成ValueWrapper 類型接下# return 基本操作4可以發(fā)現(xiàn)，C# F# C# F# let # C# 中的查實現(xiàn)了 計算表達式之后，再回到 C#。12.18 bind 基本操作return 用于把結(jié)果打包成ValueWrapper 類型接下# 12.5.3 F# Bind Return 12.18 F# F# (),funn(),funm let add = n + mlet sub=n value.Return(n*m)每在計算表達式中使le

37、t! Bind 為 函數(shù)返回 它分配符號 n ；Bind let! let 12.18 n = 可以使用Value 屬性，但是，對于值是隱藏的計算，唯一能過 Bind 成員。計算的其余部分轉(zhuǎn)換成函數(shù)，為計算提供了很大的靈活性。Bind Bind None，那么，道最后結(jié)果就是 None，而不管這個函數(shù)的結(jié)果如何。這樣，bind 操作不會調(diào)用給定的函數(shù)，因為作為參數(shù)使用的選項值是不包含實際值；在其他情況下，bind 的示例還表明，多個 let! 結(jié)構(gòu)會轉(zhuǎn)換成嵌套調(diào)用 Bind 成員。這是因為，作為給這個（continatio后調(diào)用 Return 成員，是使用 return 結(jié)構(gòu)創(chuàng)建的。bind

38、return 名中泛型類型 M 的變化：BindM* (T-M)- Return:T-M ValueWrapperT 類型。通常，bind 操作為了調(diào)用指定的函數(shù)，需要知道如何從計算類型中獲得值。當計算類型攜帶額外的信息時，bind 操作也需要把由第一個參數(shù)值（M ）所攜帶的額外信息，和從函數(shù)調(diào)用的結(jié)果（類型為 M）提取的信息組合起來，把它們作為整體結(jié)果的一部分返回。return 使用標識符 value 來構(gòu)造計算，這個標識符就是普通的 F# 單 12.19 實現(xiàn)了一個簡單的F# bind return 名中泛型類型 M 的變化：BindM* (T-M)- Return:T-M ValueWr

39、apperT 類型。通常，bind 操作為了調(diào)用指定的函數(shù)，需要知道如何從計算類型中獲得值。當計算類型攜帶額外的信息時，bind 操作也需要把由第一個參數(shù)值（M ）所攜帶的額外信息，和從函數(shù)調(diào)用的結(jié)果（類型為 M）提取的信息組合起來，把它們作為整體結(jié)果的一部分返回。return 使用標識符 value 來構(gòu)造計算，這個標識符就是普通的 F# 單 12.19 實現(xiàn)了一個簡單的F# uilder12.19 memberx.Bind(Value(v),f)=f(v) member x.Return(v) = Value(v)- letvalue=newBind 成員1 成的，使用差別聯(lián)合的 Valu

40、e 識別器作為一個模式，實際值將分配給符號 v就可以調(diào)用計算 f 能夠返回此調(diào)用的結(jié)果，作為整個計算的結(jié)果。Return 12.18 中的計算表達式。F# return let()=valuelet n returnnval: unit-bind ValueWrapperT 對ValueWrapper ! ValueWrapper C# 來初始化 from 子句。在查詢語法中的let 子句，大致相當于計算表達式中 let 在12.15 ValueWrapper12.5.4 C# 在12.14 SelectMany C# select Select from SelectMany from Fl

41、et! ValueWrapper SelectMany ，12.20 12.20 icclassspublicFunc selector) returnnewpublic s(this ValueWrapper source, 的值時，使用標準的點表示法，用于從查詢語法轉(zhuǎn)換期間，C# 將能夠找到它們。Select SelectMany ，F(xiàn)# 的Bind 以這兩個值作為參數(shù)，調(diào)用第二個函數(shù)2在12.18 12.6 12.4 F# Bind 處理的是選項類型計算表達式，只有當值是 Some(x) 而不是 None lambda NoneF# C# LINQ F# 是有兩個成員的 F# Optio

42、n.bind bind 12.21 typeOptionBuilder()memberx.Bind(opt,以這兩個值作為參數(shù)，調(diào)用第二個函數(shù)2在12.18 12.6 12.4 F# Bind 處理的是選項類型計算表達式，只有當值是 Some(x) 而不是 None lambda NoneF# C# LINQ F# 是有兩個成員的 F# Option.bind bind 12.21 typeOptionBuilder()memberx.Bind(opt,f)= match opt with|Some(value)-|_ - memberx.Return(v)=letoption=newBind

43、 成員首先從第一個參數(shù)的選項值中， 提取值， 這類似于前面實現(xiàn)的ValueWrapper Bind 值綁定到使用 None，作為整個計算表達式的結(jié)果3Return 成員有一個參數(shù)值，必須返回計算類型的值。在optionSome 的示例中，計算類型是C# Option Select SelectMany 12.22 12.22 icclassspublicicOptionSelectS,(thisOptionsource,Funcselector)returnpublic sicOptionSelectMany (this Option source,FuncS,Option F# 中，函數(shù)稱為

44、 Option.map，C# （Map是先看到 LINQ 的話，那么，首先可能會把方法稱為 SelectMap 方法(thisOptionsource,Funcselector)returnpublic sicOptionSelectMany (this Option source,FuncS,Option F# 中，函數(shù)稱為 Option.map，C# （Map是先看到 LINQ 的話，那么，首先可能會把方法稱為 SelectMap 方法1 用 C# 寫過 bind 操作；在這里，外用 Bind 擴展方法2。要調(diào)用格式化函數(shù) resultSelectorBind Map lambda 法3來

45、自源的原始值。在 lambda （sourceValue 的變量Bind for 12.3 F# yield return let! 就能運行。這是故意的，因為這些第一組基本操作更仍然需要實現(xiàn)方法（類似于F# 的函數(shù)SomeNone前面看到的兩個例子，在 Haskell monad能單（maybe monadMaybe Haskell F# option 類12.7 # ，12.7 # ，。12.7.1 typeLogging|Log ofT* ValueWrapper F# 12.23 的實現(xiàn)。最重要的是 Bind Bind 成員參數(shù)的函數(shù)）12.23 typeLoggingBuilder(

46、)memberx.Bind(Log(value,logs1),f)= let(Log(newValue,logs2)=Log(newValue,logs1 - memberx.Zero()- Log(),letlog=newBind option ValueWrapper 以運行給定的函數(shù)2（Return Zero 成員很簡單。Return 需要把實際值打包到unitLogging letlog=newBind option ValueWrapper 以運行給定的函數(shù)2（Return Zero 成員很簡單。Return 需要把實際值打包到unitLogging 類型中，Zero letlogMessage(s)Log(),vallogMessage:string-unit Bind在12.7.2 l