序列 (F#)
「序列」(Sequence) 是一連串的邏輯項目，所有項目都是相同型別。 如果您有大型且排序過的資料集合，但不需要使用所有項目時，序列就特別有用。 個別序列項目只在需要時才會進行計算，因此在不使用所有項目的情況下，序列提供的效能優於清單。 序列是透過 seq<'T> 型別所表示，這是 IEnumerable<T> 的別名。 因此，可以將實作 System.IEnumerable 的任何 .NET Framework 型別當成序列使用。 序列模組支援與序列相關的操作。
序列運算式
「序列運算式」(Sequence Expression) 是評估為序列的運算式。 序列運算式可以採用數種形式。 最簡單的形式會指定範圍。 例如，seq { 1 .. 5 } 建立含有五個項目的序列 (包含端點 1 和 5)。 您可以指定兩個雙句點之間的增量 (或減量)。 例如，下列程式碼會建立 10 的倍數的序列。
// Sequence that has an increment.
seq { 0 .. 10 .. 100 }
序列運算式是由產生序列之值的 F# 運算式所構成。 它們可以使用 yield 關鍵字產生會變成系列一部分的值。
範例如下。
seq { for i in 1 .. 10 do yield i * i }
您可以使用 -> 運算子，而非 yield，在此情況下，您可以省略 do 關鍵字 (如下列範例所示)。
seq { for i in 1 .. 10 -> i * i }
下列程式碼會將座標組清單及索引產生為表示格線的陣列。
let (height, width) = (10, 10)
seq { for row in 0 .. width - 1 do
for col in 0 .. height - 1 do
yield (row, col, row*width + col)
}
序列中使用的 if 運算式是一種篩選器。 例如，若要產生只有質數的序列，且假設您有型別為 int -> bool 的函式 isprime，則請如下建構序列。
seq { for n in 1 .. 100 do if isprime n then yield n }
當您在反覆項目中使用 yield 或 -> 時，每個反覆項目都必須產生序列的一個項目。 如果每個反覆項目都產生由多個元素所組成的序列，請使用 yield!。 在此情況下，會串連每個反覆項目上產生的項目，然後產生最終序列。
您可以使用序列運算式來合併多個運算式。 每個運算式所產生的項目都會串連在一起。 如需範例，請參閱本主題的＜範例＞章節。
範例
第一個範例使用含有反覆項目、篩選器和 yield 的序列運算式，來產生陣列。 這個程式碼會將 1 到 100 之間的質數序列列印至主控台。
// Recursive isprime function.
let isprime n =
let rec check i =
i > n/2 || (n % i <> 0 && check (i + 1))
check 2
let aSequence = seq { for n in 1..100 do if isprime n then yield n }
for x in aSequence do
printfn "%d" x
下列程式碼使用 yield 來建立九九乘法表，其中包含由三個項目所組成的 Tuple，這三個項目各包含兩個因數和一個乘積。
let multiplicationTable =
seq { for i in 1..9 do
for j in 1..9 do
yield (i, j, i*j) }
下列範例示範如何使用 yield! 將個別序列結合為一個最終序列。 在此情況下，二進位樹狀結構中每個子樹狀結構的序列會在遞迴函式中串連，以產生最終序列。
// Yield the values of a binary tree in a sequence.
type Tree<'a> =
| Tree of 'a * Tree<'a> * Tree<'a>
| Leaf of 'a
// inorder : Tree<'a> -> seq<'a>
let rec inorder tree =
seq {
match tree with
| Tree(x, left, right) ->
yield! inorder left
yield x
yield! inorder right
| Leaf x -> yield x
}
let mytree = Tree(6, Tree(2, Leaf(1), Leaf(3)), Leaf(9))
let seq1 = inorder mytree
printfn "%A" seq1
使用序列
序列支援許多與清單相同的函式。 序列也使用索引鍵產生函式，支援分組和計算這類作業。 序列也支援較多種函式來擷取子序列。
多種資料類型 (例如清單、陣列、集合 (Set) 和對應) 都是隱含的序列，原因是它們都是可列舉的集合 (Collection)。 除了實作 IEnumerable<T> 的任何 .NET Framework 資料類型之外，採用序列做為引數的函式也可以與任何通用 F# 資料類型搭配運作。 與此相反的是採用清單做為引數的函式，它只可採用清單。 型別 seq<'a> 是 IEnumerable<'a> 的型別縮寫。 這表示任何實作泛型 IEnumerable<T> 的型別 (包含 F# 中的陣列、清單、集合 (Set) 和對應，也包含大部分 .NET Framework 集合 (Collection) 型別) 都與 seq 型別相容，而且可以用於需要序列的位置。
模組函式
Microsoft.FSharp.Collections 命名空間中的序列模組包含與序列搭配使用的函式。 這些函式也可以與清單、陣列、對應和集合 (Set) 搭配使用，原因是這些型別都是可列舉的，因此可以視為序列。
建立序列
您可以使用序列運算式 (如前所述) 或使用特定函式，來建立序列。
您可以使用 Seq.empty 建立空序列，也可以使用 Seq.singleton 建立只有一個指定項目的序列。
let seqEmpty = Seq.empty
let seqOne = Seq.singleton 10
您可以使用 Seq.init 建立透過所提供之函式建立項目的序列。 您也需要提供序列的大小。 此函式與 List.init 一樣，但在您逐一查看序列之前，都不會建立項目。 下列程式碼說明如何使用 Seq.init。
let seqFirst5MultiplesOf10 = Seq.init 5 (fun n -> n * 10)
Seq.iter (fun elem -> printf "%d " elem) seqFirst5MultiplesOf10
輸出為
0 10 20 30 40
使用 Seq.ofArray 和 Seq.ofList<'T> 函式 (F#)，您可以透過陣列和清單建立序列。 不過，您也可以使用轉型運算子，將陣列和清單轉換為序列。 下列程式碼同時顯示這兩種技術。
// Convert an array to a sequence by using a cast.
let seqFromArray1 = [| 1 .. 10 |] :> seq<int>
// Convert an array to a sequence by using Seq.ofArray.
let seqFromArray2 = [| 1 .. 10 |] |> Seq.ofArray
使用 Seq.cast，您可以透過弱式型別集合建立序列 (例如定義於 System.Collections 的項目)。 這類弱式型別集合的項目型別為 Object，而且使用非泛型 IEnumerable<T> 型別予以列舉。 下列程式碼說明如何使用 Seq.cast，將 ArrayList 轉換為序列。
open System
let mutable arrayList1 = new System.Collections.ArrayList(10)
for i in 1 .. 10 do arrayList1.Add(10) |> ignore
let seqCast : seq<int> = Seq.cast arrayList1
您可以使用 Seq.initInfinite 函式，定義無限序列。 針對這類序列，請提供函式以透過項目的索引來產生每個項目。 因為延遲評估，所以可能會發生無限序列；項目是視需要呼叫您指定的函式來建立。 下列程式碼範例產生浮點數的無限序列，在此情況下，替代連續整數的平方倒數數列。
let seqInfinite = Seq.initInfinite (fun index ->
let n = float( index + 1 )
1.0 / (n * n * (if ((index + 1) % 2 = 0) then 1.0 else -1.0)))
printfn "%A" seqInfinite
Seq.unfold 會透過採用狀態的計算函式產生序列，並進行轉換，以產生序列中的每個後續項目， 狀態只是一個值，用來計算每個項目，而且可以在計算每個項目時變更。 Seq.unfold 的第二個引數是用來啟動序列的初始值。 Seq.unfold 使用狀態的選項類型，可讓您傳回 None 值來結束序列。 下列程式碼顯示 unfold 作業所產生的兩個序列範例 (seq1 和 fib)。 第一個序列 (seq1) 只是數目最多 100 個的簡單序列。 第二個序列 (fib) 則使用 unfold 計算 Fibonacci 序列。 因為 Fibonacci 序列的每個項目都是前兩個 Fibonacci 數字的總和，所以狀態值是由序列中前兩個數字所組成的 Tuple。 初始值是 (1,1)，即序列中的前兩個數字。
let seq1 = Seq.unfold (fun state -> if (state > 20) then None else Some(state, state + 1)) 0
printfn "The sequence seq1 contains numbers from 0 to 20."
for x in seq1 do printf "%d " x
let fib = Seq.unfold (fun state ->
if (snd state > 1000) then None
else Some(fst state + snd state, (snd state, fst state + snd state))) (1,1)
printfn "\nThe sequence fib contains Fibonacci numbers."
for x in fib do printf "%d " x
其輸出如下：
序列 seq1 包含從 0 到 20 的數字。
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
序列 fib 包含 Fibonacci 的數字。
2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
下列程式碼範例使用這裡所說明的多個序列模組函式，以產生和計算無限序列的值。 這個程式碼可能需要幾分鐘的時間執行。
// infiniteSequences.fs
// generateInfiniteSequence generates sequences of floating point
// numbers. The sequences generated are computed from the fDenominator
// function, which has the type (int -> float) and computes the
// denominator of each term in the sequence from the index of that
// term. The isAlternating parameter is true if the sequence has
// alternating signs.
let generateInfiniteSequence fDenominator isAlternating =
if (isAlternating) then
Seq.initInfinite (fun index -> 1.0 /(fDenominator index) * (if (index % 2 = 0) then -1.0 else 1.0))
else
Seq.initInfinite (fun index -> 1.0 /(fDenominator index))
// The harmonic series is the series of reciprocals of whole numbers.
let harmonicSeries = generateInfiniteSequence (fun index -> float index) false
// The harmonic alternating series is like the harmonic series
// except that it has alternating signs.
let harmonicAlternatingSeries = generateInfiniteSequence (fun index -> float index) true
// This is the series of reciprocals of the odd numbers.
let oddNumberSeries = generateInfiniteSequence (fun index -> float (2 * index - 1)) true
// This is the series of recipocals of the squares.
let squaresSeries = generateInfiniteSequence (fun index -> float (index * index)) false
// This function sums a sequence, up to the specified number of terms.
let sumSeq length sequence =
Seq.unfold (fun state ->
let subtotal = snd state + Seq.nth (fst state + 1) sequence
if (fst state >= length) then None
else Some(subtotal,(fst state + 1, subtotal))) (0, 0.0)
// This function sums an infinite sequence up to a given value
// for the difference (epsilon) between subsequent terms,
// up to a maximum number of terms, whichever is reached first.
let infiniteSum infiniteSeq epsilon maxIteration =
infiniteSeq
|> sumSeq maxIteration
|> Seq.pairwise
|> Seq.takeWhile (fun elem -> abs (snd elem - fst elem) > epsilon)
|> List.ofSeq
|> List.rev
|> List.head
|> snd
// Compute the sums for three sequences that converge, and compare
// the sums to the expected theoretical values.
let result1 = infiniteSum harmonicAlternatingSeries 0.00001 100000
printfn "Result: %f ln2: %f" result1 (log 2.0)
let pi = Math.PI
let result2 = infiniteSum oddNumberSeries 0.00001 10000
printfn "Result: %f pi/4: %f" result2 (pi/4.0)
// Because this is not an alternating series, a much smaller epsilon
// value and more terms are needed to obtain an accurate result.
let result3 = infiniteSum squaresSeries 0.0000001 1000000
printfn "Result: %f pi*pi/6: %f" result3 (pi*pi/6.0)
搜尋和尋找項目
序列可支援清單所提供的功能：Seq.exists、Seq.exists2、Seq.find、Seq.findIndex、Seq.pick、Seq.tryFind 和 Seq.tryFindIndex。 這些適用於序列之函式的版本只會評估到序列正在搜尋的項目處。 如需詳細資訊，請參閱清單。
取得子序列
Seq.filter 和 Seq.choose 與適用於清單的對應函式相同，差異在於評估序列項目之前不會進行篩選和選擇。
Seq.truncate 會透過另一個序列來建立序列，但是將序列限制為指定的項目數。 Seq.take 會建立新的序列，其中只包含序列開頭處指定的項目數。 如果序列的項目數少於您指定要採用的項目數，則 Seq.take 會擲回 InvalidOperationException。 Seq.take 與 Seq.truncate 的差異在於如果項目數少於您指定的數目，Seq.truncate 並不會產生錯誤。
下列程式碼顯示 Seq.truncate 和 Seq.take 之間的行為和差異。
let mySeq = seq { for i in 1 .. 10 -> i*i }
let truncatedSeq = Seq.truncate 5 mySeq
let takenSeq = Seq.take 5 mySeq
let truncatedSeq2 = Seq.truncate 20 mySeq
let takenSeq2 = Seq.take 20 mySeq
let printSeq seq1 = Seq.iter (printf "%A ") seq1; printfn ""
// Up to this point, the sequences are not evaluated.
// The following code causes the sequences to be evaluated.
truncatedSeq |> printSeq
truncatedSeq2 |> printSeq
takenSeq |> printSeq
// The following line produces a run-time error (in printSeq):
takenSeq2 |> printSeq
在錯誤發生之前，輸出如下。
1 4 9 16 25
1 4 9 16 25 36 49 64 81 100
1 4 9 16 25
1 4 9 16 25 36 49 64 81 100
使用 Seq.takeWhile，就可以指定述詞函式 (布林函式)，以及透過另一個序列 (由述詞為 true 之原始序列的那些項目所組成) 來建立序列，但是在述詞傳回 false 的第一個項目之前停止。 Seq.skip 傳回序列，這個序列會略過另一個序列之第一個項目的指定數目，並傳回其餘項目。 Seq.skipWhile 傳回序列，這個序列會在述詞傳回 true 時略過另一個序列的第一個項目，然後傳回其餘項目，而這是從述詞傳回 false 的第一個項目開始。
下列程式碼範例說明 Seq.takeWhile、Seq.skip 和 Seq.skipWhile 之間的行為和差異。
// takeWhile
let mySeqLessThan10 = Seq.takeWhile (fun elem -> elem < 10) mySeq
mySeqLessThan10 |> printSeq
// skip
let mySeqSkipFirst5 = Seq.skip 5 mySeq
mySeqSkipFirst5 |> printSeq
// skipWhile
let mySeqSkipWhileLessThan10 = Seq.skipWhile (fun elem -> elem < 10) mySeq
mySeqSkipWhileLessThan10 |> printSeq
輸出如下。
1 4 9
36 49 64 81 100
16 25 36 49 64 81 100
轉換序列
Seq.pairwise 會建立新的序列，這個序列會將輸入序列的連續項目分組為 Tuple。
let printSeq seq1 = Seq.iter (printf "%A ") seq1; printfn ""
let seqPairwise = Seq.pairwise (seq { for i in 1 .. 10 -> i*i })
printSeq seqPairwise
printfn ""
let seqDelta = Seq.map (fun elem -> snd elem - fst elem) seqPairwise
printSeq seqDelta
Seq.windowed 和 Seq.pairwise 相同，差異在於它會產生內含序列中相鄰項目之複本的陣列序列 (「視窗」 (Window))，而不是產生 Tuple 序列。 您可以指定每個陣列中想要的相鄰項目數。
下列程式碼範例會示範 Seq.windowed 的用法。 在此情況下，視窗中的項目數是 3。 此範例使用前面程式碼範例所定義的 printSeq。
let seqNumbers = [ 1.0; 1.5; 2.0; 1.5; 1.0; 1.5 ] :> seq<float>
let seqWindows = Seq.windowed 3 seqNumbers
let seqMovingAverage = Seq.map Array.average seqWindows
printfn "Initial sequence: "
printSeq seqNumbers
printfn "\nWindows of length 3: "
printSeq seqWindows
printfn "\nMoving average: "
printSeq seqMovingAverage
輸出如下。
初始序列：
1.0 1.5 2.0 1.5 1.0 1.5
Windows of length 3:
[|1.0; 1.5; 2.0|] [|1.5; 2.0; 1.5|] [|2.0; 1.5; 1.0|] [|1.5; 1.0; 1.5|]
Moving average:
1.5 1.666666667 1.5 1.333333333
具有多個序列的作業
Seq.zip 和 Seq.zip3 採用兩個或三個序列，並產生 Tuple 序列。 這些函式與適用於清單的對應函式類似。 並沒有對應的功能可以將一個序列分成兩個以上的序列。 如果您的序列需要此功能，請將該序列轉換為清單，並使用 List.unzip。
排序、比較和分組
清單所支援的排序函式也適用於序列。 這包括 Seq.sort 和 Seq.sortBy。 這些函式會逐一查看整個序列。
您可以使用 Seq.compareWith 函式比較兩個序列。 這個函式接著會比較連續項目，並在遇到第一個不相等的配對時停止。 任何其他項目都不會導致比較。
下列程式碼顯示如何使用 Seq.compareWith。
let sequence1 = seq { 1 .. 10 }
let sequence2 = seq { 10 .. -1 .. 1 }
// Compare two sequences element by element.
let compareSequences = Seq.compareWith (fun elem1 elem2 ->
if elem1 > elem2 then 1
elif elem1 < elem2 then -1
else 0)
let compareResult1 = compareSequences sequence1 sequence2
match compareResult1 with
| 1 -> printfn "Sequence1 is greater than sequence2."
| -1 -> printfn "Sequence1 is less than sequence2."
| 0 -> printfn "Sequence1 is equal to sequence2."
| _ -> failwith("Invalid comparison result.")
在前一個程式碼中，只會計算並檢查第一個項目，而結果是 -1。
Seq.countBy 採用的函式會為每個項目產生「索引鍵」(Key) 值。 在每個項目上呼叫此函式，就會產生每個項目的索引鍵。 Seq.countBy 接著會傳回內含索引鍵值的序列，以及已產生所有索引鍵值的項目數計數。
let mySeq1 = seq { 1.. 100 }
let printSeq seq1 = Seq.iter (printf "%A ") seq1; printfn ""
let seqResult = Seq.countBy (fun elem -> if elem % 3 = 0 then 0
elif elem % 3 = 1 then 1
else 2) mySeq1
printSeq seqResult
輸出如下。
(1, 34) (2, 33) (0, 33)
前一個輸出顯示已產生索引鍵 1 的原始序列有 34 個項目、已產生索引鍵 2 的原始序列有 33 個值，而已產生索引鍵 0 的原始序列有 33 個值。
您可以呼叫 Seq.groupBy，將序列的項目進行分組。 Seq.groupBy 採用序列以及透過項目產生索引鍵的函式。 此函式會在序列的每個項目上執行。 Seq.groupBy 會傳回 Tuple 序列，而每個 Tuple 的第一個項目是索引鍵，第二個項目則是產生該索引鍵之項目的序列。
下列程式碼範例顯示如何使用 Seq.groupBy，將 1 到 100 個數目的序列分割為三個具有不同索引鍵值 0、1 和 2 的群組。
let sequence = seq { 1 .. 100 }
let printSeq seq1 = Seq.iter (printf "%A ") seq1; printfn ""
let sequences3 = Seq.groupBy (fun index ->
if (index % 3 = 0) then 0
elif (index % 3 = 1) then 1
else 2) sequence
sequences3 |> printSeq
輸出如下。
(1, seq [1; 4; 7; 10; ...]) (2, seq [2; 5; 8; 11; ...]) (0, seq [3; 6; 9; 12; ...])
您可以呼叫 Seq.distinct，建立不含重複項目的序列。 您也可以使用 Seq.distinctBy，其採用要在每個項目上呼叫的索引鍵產生函式。 產生的序列會包含原始序列中具有唯一索引鍵的項目；如果後面的項目所產生的索引鍵與前面的項目重複，則會予以捨棄。
下列程式碼範例說明如何使用 Seq.distinct。 產生代表二進位數字的序列，然後顯示唯一的差異項目 0 和 1，以示範 Seq.distinct。
let binary n =
let rec generateBinary n =
if (n / 2 = 0) then [n]
else (n % 2) :: generateBinary (n / 2)
generateBinary n |> List.rev |> Seq.ofList
printfn "%A" (binary 1024)
let resultSequence = Seq.distinct (binary 1024)
printfn "%A" resultSequence
下列程式碼會示範 Seq.distinctBy 的用法，方法是從含有負數和正數的序列開始，並使用絕對值函式做為索引鍵產生函式。 產生的序列會遺失所有與序列中負數對應的正數，原因是負數出現在序列的前面，因此會予以選取，而非具有相同絕對值或索引鍵的正數。
let inputSequence = { -5 .. 10 }
let printSeq seq1 = Seq.iter (printf "%A ") seq1; printfn ""
printfn "Original sequence: "
printSeq inputSequence
printfn "\nSequence with distinct absolute values: "
let seqDistinctAbsoluteValue = Seq.distinctBy (fun elem -> abs elem) inputSequence
seqDistinctAbsoluteValue |> printSeq
唯讀和已快取序列
Seq.readonly 會建立序列的唯讀複本。 如果您具有讀寫集合 (例如陣列)，而且不想要修改原始集合，Seq.readonly 就十分有用。 此函式可用來保留資料封裝。 在下列程式碼範例中，會建立含有陣列的型別。 屬性會公開陣列 (而非傳回陣列)，並使用 Seq.readonly 傳回透過陣列所建立的序列。
type ArrayContainer(start, finish) =
let internalArray = [| start .. finish |]
member this.RangeSeq = Seq.readonly internalArray
member this.RangeArray = internalArray
let newArray = new ArrayContainer(1, 10)
let rangeSeq = newArray.RangeSeq
let rangeArray = newArray.RangeArray
// These lines produce an error:
//let myArray = rangeSeq :> int array
//myArray.[0] <- 0
// The following line does not produce an error.
// It does not preserve encapsulation.
rangeArray.[0] <- 0
Seq.cache 會建立序列的已儲存版本。 為了避免重新評估序列，或者您有多個使用序列的執行緒，但必須確保每個項目都只作用一次時，請使用 Seq.cache。 如果有多個執行緒使用您的序列，則您可以讓其中一個執行緒列舉和計算原始序列的值，其餘執行緒則可以使用已快取的序列。
對序列執行計算
簡單的算術運算是與清單類似，例如 Seq.average、Seq.sum、Seq.averageBy、Seq.sumBy 等。
Seq.fold、Seq.reduce 和 Seq.scan 與適用於清單的對應函式類似。 序列支援清單所支援之函式的完整變化子集。 如需詳細資訊與範例，請參閱清單 (F#)。