Sıraları (F#)
A sıra mantıksal bir dizi öğelerinin tümü, bir tür.Büyük bir veri toplama sipariş var ancak mutlaka tüm öğeleri kullanmayı düşünmüyorsanız, serileri özellikle yararlı olur.Tek tek sıra öğeleri yalnızca olarak hesaplanan bir sıra listesi tüm öğeleri kullanılan durumlarda daha iyi performans sağlayabilmesi gerekli.Sıraları temsil ettiği seq<'T> bir diğer ad türü için IEnumerable<T>.Bu nedenle, herhangi bir.Uygulayan net Framework türü System.IEnumerable bir dizi olarak kullanılabilir.Seq modülü sıralarını ilgili uygulamaları için destek sağlar.
Sıra ifadeleri
A sıra ifade bir sıra sonucunu veren bir ifade edilir.Sıra ifadeleri çok sayıda formu alabilir.En basit şekliyle bir aralık belirler.Örneğin, seq { 1 .. 5 } , bitiş noktası 1 ve 5 de dahil olmak üzere beş öğeleri içeren bir sıra oluşturur.Ayrıca bir artış belirtin (veya azaltma) arasında çift iki nokta.Örneğin, aşağıdaki kod 10 'un katları dizisi oluşturur.
// Sequence that has an increment.
seq { 0 .. 10 .. 100 }
Sıra ifadeleri sıralı değerler üreten F# ifadeler yapılır.Kullanabileceklerini yield dizisinin bir parçası haline değerler üretmek için anahtar sözcük.
Aşağıdaki örnek gösterilebilir.
seq { for i in 1 .. 10 do yield i * i }
Kullanabileceğiniz -> operatörü yerine yield, atabilirsiniz, bu durumda do anahtar sözcüğünü aşağıdaki örnekte gösterildiği gibi.
seq { for i in 1 .. 10 -> i * i }
Aşağıdaki kod, kılavuz temsil eden bir dizi içine koordinat çifti ile birlikte bir dizin listesini oluşturur.
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)
}
Bir if ifadesidir bir sırada kullanılan filtre.Örneğin, yalnızca asal sayıların bir işlevi olduğunu varsayarsak, bir dizi oluşturmak için isprime türü int -> bool, sırası aşağıdaki gibi oluşturun.
seq { for n in 1 .. 100 do if isprime n then yield n }
Kullandığınızda yield veya -> bir yineleme içinde tek bir öğe sırası oluşturmak için her tekrarında beklenir.Bir dizi öğelerinin her tekrarında üretir, kullanın yield!.Bu durumda, her yineleme üzerinde oluşturulan öğeleri son sıra üretmek için birleşir.
Bir sıra ifadesinde birlikte birden çok ifadelerini de birleştirebilirsiniz.Her deyim tarafından oluşturulmuş öğeleri birbirine birleşir.Örneğin, bu konunun "Örnekleri" bölümüne bakın.
Örnekler
İlk örnek bir yineleme, filtre ve bir dizi oluşturmak için bir ödeme içeren bir sıra ifadesini kullanır.Bu kod, bir dizi asal sayı 1 ile 100 konsola yazdırır.
// 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
Aşağıdaki kod yield dizilerini üç öğe her iki etken ve ürün oluşan oluşan çarpım tablosu oluşturmak için.
let multiplicationTable =
seq { for i in 1..9 do
for j in 1..9 do
yield (i, j, i*j) }
Aşağıdaki örnek kullanımını gösterir yield! tek tek serileri tek bir son sıra halinde birleştirmek için.Bu durumda, her alt ağaçtaki bir ikili aðaç sıralarını son sıra üretmek için yinelemeli işlevin birleşir.
// 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
Dizileri kullanma
Sıraları aynı işlevlerin çoğunu destekleyen listeler.Sıraları da gruplandırma ve anahtar oluşturma işlevlerini kullanarak sayım gibi işlemleri destekler.Sıraları sıraları ayıklanması için daha farklı işlevleri de destekler.
Uygulama geliþtiriyorsanýz sýralanabilir Koleksiyonlar oldukları için birçok veri listeleri, diziler, kümeleri ve haritalar gibi dolaylı olarak sıraları türleridir.Ortak F# veri türleri, yanında herhangi biriyle bir işlev bağımsız değişken olarak bir dizi alır çalışır.net Framework veri türü, uygulayan IEnumerable<T>.Bu liste listeler yalnızca alabilir bir argüman olarak geçen bir işlev kontrast.Tür seq<'a> türü kısaltması olan IEnumerable<'a>.Genel uygulayan her türlü yani IEnumerable<T>, diziler, listeleri içeren ayarlar ve F# ve çoğu da eşler.net Framework koleksiyon türleri, ile uyumlu seq yazın ve bir sıra beklenen her yerde kullanılabilir.
Modülü işlevleri
Seq modülü , Microsoft.FSharp.Collections ad sıralarıyla çalışma işlevleri içerir.Bu işlevler listeleri, diziler, haritalar ve ayarlar gibi çalışır, çünkü o türden tüm sýralanabilir bulunur ve bu nedenle sırası olarak ele alınabilir.
Sıralar oluşturma
Sıraları sıra ifadeler, daha önce açıklandığı gibi kullanarak veya belirli işlevleri kullanarak oluşturabilirsiniz.
Boş bir sıra kullanarak oluşturabileceğiniz Seq.empty, tek belirtilen öğe sırasını kullanarak oluşturabilirsiniz veya Seq.singleton.
let seqEmpty = Seq.empty
let seqOne = Seq.singleton 10
Kullanabileceğiniz Seq.init için öğeleri oluşturulur sağladığınız işlevini kullanarak bir sıra oluşturmak için.Sıra için bir boyut da sağlar.Bu işlev gibi olan List.init, sıra yineleme yapmak kadar öğeleri oluşturulmamış olmasıdır.Aşağıdaki kodu kullanımını göstermektedir Seq.init.
let seqFirst5MultiplesOf10 = Seq.init 5 (fun n -> n * 10)
Seq.iter (fun elem -> printf "%d " elem) seqFirst5MultiplesOf10
Çıkış
0 10 20 30 40
Kullanarak Seq.ofArray ve Seq.ofList<'T> İşlevi (F#), sıraları diziler ve listeleri oluşturabilirsiniz.Ancak, aynı zamanda diziler ve listeleri serileri cast işlecini kullanarak dönüştürebilirsiniz.Aşağıdaki kodda iki teknikleri gösterilir.
// 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
Kullanarak Seq.cast, tanımlanmış olanlar gibi zayıf yazılı bir koleksiyondan bir sıra oluşturmak System.Collections.Öğe türü zayıf yazılan bu tür koleksiyonlara sahip Object ve genel olmayan kullanılarak numaralandırılır IEnumerable<T> türü.Aşağıdaki kodu kullanımını göstermektedir Seq.cast dönüştürmek için bir ArrayList bir sıra halinde.
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
Sonsuz sıraları kullanarak tanımlayabilirsiniz Seq.initInfinite işlevi.Böyle bir sıra için her öğe öğenin dizin oluşturur bir işlev sağlar.Sonsuz sıraları nedeniyle geç değerlendirme olasıdır; öğeleri belirttiğiniz işlevini çağırarak gerektiği şekilde oluşturulur.Aşağıdaki kod örneği, devrik değeridir karelerinin ardışık tamsayıların değişen dizi kayan nokta numarası, bu durumda, sonsuz bir sıra oluşturur.
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 bir durum alır ve sıradaki her alt öğe üretmek için dönüştüren bir hesaplama işlevi bir sıra oluşturur.Durumu her öğe hesaplamak için kullanılır ve her öğe hesaplanan gibi değiştirebilirsiniz yalnızca bir değerdir.İkinci bağımsız değişken için Seq.unfold serisi başlatmak için kullanılan başlangıç değeridir.Seq.unfolddurumu sırasını döndürerek sonlandırmak sağlayan bir seçenek türünü kullanır None değeri.Aşağıdaki kod iki sıraları, örnekleri gösterir seq1 ve fib, tarafından oluşturulan bir unfold işlem.İlk seq1, yalnızca basit bir sıra numaraları 100 kadar.İkincisi, fib, kullandığı unfold Fibonacci serisi hesaplamak için.Fibonacci dizisindeki her öğe toplamı, önceki iki Fibonacci sayı olduğundan, durumu, önceki iki sayı sırada oluşan kayıt düzeni değerdir.İlk değer (1,1), ilk iki sıra numaraları.
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
Çıktı aşağıdaki gibidir:
Sıra seq1 20 0 numaralarını içerir.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Fibonacci sayı dizisi fib içerir.
2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
Aşağıdaki kod üretmek ve sonsuz sıralarının değerleri hesaplamak için burada açıklanan sıra modülü işlevlerin çoğunu kullanan bir örnektir.Kod çalıştırmak için birkaç dakika sürebilir.
// 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)
Arama ve öğeleri bulma
Sıraları listelerle kullanılabilen işlevselliği destekler: Seq.exists, Seq.exists2, Seq.find, Seq.findIndex, Seq.pick, Seq.tryFind, ve Seq.tryFindIndex.Sıra için Aranan öğe kadar serileri için kullanılabilen bu işlevlerin sürümleri değerlendirin.Örnekler için bkz: listeler.
Sıraları elde etme
SEQ.Filter ve Seq.choose olan filtreleme ve seçim oluşmaz dışında sırası öğeleri değerlendirilir kadar listeleri için kullanılamayan ilgili işlevleri gibi.
SEQ.Truncate başka bir serisinden bir sıra oluşturur, ancak belirtilen sayıda öğe sırası ile sınırlar.SEQ.Take belirtilen sayıda bir sıra başlangıç öğelerini içeren yeni bir sıra oluşturur.Sıradaki yararlanmak için belirttiğiniz'den daha az öğe varsa Seq.take atar bir InvalidOperationException.Arasındaki fark Seq.take ve Seq.truncate olan Seq.truncate az sayı, belirttiğiniz öğelerin sayısı ise, bir hata neden olmaz.
Aşağıdaki kod davranışını gösterir ve arasındaki farklılıklar Seq.truncate ve 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
Hata oluşmadan önce çıktı aşağıdaki gibidir.
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
Kullanarak Seq.takeWhile, doðrulama işlevi (Boolean işlevi) belirtin ve yüklemi olduğu özgün sıra bu öğelerden oluşan bir başka serisinden bir sıra oluşturmak true, ancak kendisi için karşılaştırma işlevi ilk öğesinden önce DUR false.SEQ.Skip başka bir sıra ilk öğelerinin belirli sayıda atlar ve geri kalan öğeleri döndürür sırası döndürür.SEQ.skipWhile yüklemi verir sürece başka bir sıra ilk öğelerinin atlar sırası döndürür true, kendisi için karşılaştırma işlevi ilk öğe ile başlayarak, geri kalan öğeleri verir ve false.
Aşağıdaki kod örneği davranışını gösterir ve arasındaki farklılıklar Seq.takeWhile, Seq.skip, ve 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
Çıktı aşağıdaki gibidir.
1 4 9
36 49 64 81 100
16 25 36 49 64 81 100
Sıraları dönüştürme
SEQ.pairwise giriş sırasının birbirini izleyen öğeleri dizilerini gruplandırılmış yeni bir sıra oluşturur.
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 gibi Seq.pairwise, dizilerini bir dizi oluşturmanın yerine, bir dizi bitişik öğelerinin kopyalarını içeren diziler üretir dışında (bir Pencere) serisinden.Her dizide istediğiniz bitişik öğe sayısını belirtin.
Aşağıdaki kod örneği kullanımını gösterir Seq.windowed.Bu durumda penceresinde öğelerin sayısı 3'tür.Bu örnek kullanır printSeq, önceki kod örneğinde, tanımlanır.
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
Çıktı aşağıdaki gibidir.
Başlangıç sırası:
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
Birden çok serileri ile işlemleri
SEQ.zip ve Seq.zip3 iki veya üç sıraları alır ve dizilerini dizisini üretir.Bu işlevler için kullanılabilen ilgili işlevleri gibidir listeler.Bir sıra halinde iki veya daha fazla sıraları ayırmak için karşılık gelen hiçbir işlevi yoktur.Sırası için bu işleve gerek duyuyorsanız, bir liste sırası dönüştürmek ve kullanmak List.unzip.
Sıralama, karşılaştırma ve gruplandırma
Listeler için desteklenen sıralama işlevleri sıralarıyla da çalışır.Bu Seq.sort ve Seq.sortBy.Bu işlevler tam sırası ile yineleme.
İki sıraları kullanarak karşılaştırmak Seq.compareWith işlevi.İşlev sırayla birbirini izleyen öğeleri karşılaştırır ve ilk eşit olmayan çifti karşılaştığında durur.Herhangi bir ek öğeleri karşılaştırma katkıda değil.
Aşağıdaki kod kullanımını gösterir 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.")
Önceki kod ilk öğe hesaplanan ve inceledi ve sonuç -1 olur.
SEQ.countBy adlı bir değer üreten bir işlev alır bir anahtar her öğe için.Bir anahtarı, her öğe üzerinde bu işlevini çağırarak her öğe için oluşturulur.Seq.countByDaha sonra anahtar değerleri ve her anahtarın değerini oluşturan öğelerin sayısı sayısı içeren bir sıra döndürür.
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
Çıktı aşağıdaki gibidir.
(1, 34) (2, 33) (0, 33)
1, Anahtar üretilen orijinal sıra 34 öğeleri 2 anahtarı üretilen 33 değerler ve üretilen anahtarı 0 33 değerleri olan önceki çıktıyı göstermektedir.
Çağırarak bir dizi öğeleri gruplandırabilirsiniz Seq.groupBy.Seq.groupBybir sıra ile bir öğeden bir anahtar üreten işlevi kazanır.İşlev sırası her bir öğesi olarak yürütülür.Seq.groupByBurada her kayıt düzeni ilk öğe anahtarı, ikincisinin anahtara üreten öğelerin sırasını dizilerini bir dizi döndürür.
Aşağıdaki kod örneği kullanımını göstermektedir Seq.groupBy 0, 1 ve 2 numaraları 1 ile 100 serisi farklı anahtara sahip üç gruplar halinde bölümlemek için değerleri.
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
Çıktı aşağıdaki gibidir.
(1, seq [1; 4; 7; 10; ...]) (2, seq [2; 5; 8; 11; ...]) (0, seq [3; 6; 9; 12; ...])
Yinelenen öğeleri çağırarak ortadan kaldıran bir sıra oluşturduğunuz Seq.distinct.Veya Seq.distinctBy, her öğe üzerinde çağrılacak bir anahtar oluşturma işlevi gerçekleştirir.Sonuçta elde edilen sıra benzersiz anahtarlar olan öğeler özgün sırasının içerir; bir önceki öğe için yinelenen bir anahtar üretmek daha sonra öğeleri atılır.
Aşağıdaki kod örneği kullanımları gösterilmektedir Seq.distinct.Seq.distinctikili sayılar gösterir sıraları oluşturma ve sonra yalnızca farklı öğelere 0 ve 1 olduğunu gösteren gösterilmiştir.
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
Aşağıdaki kod gösterir Seq.distinctBy negatif ve pozitif bir sayı içeren bir sıra ile başlayan ve mutlak değer fonksiyonu anahtar oluşturma işlevini kullanarak.Çünkü negatif sayılar sıra ile görünür ve bu nedenle aynı mutlak değeri veya anahtarı pozitif sayılar yerine seçiliyken, negatif sayılar sıradaki karşılık gelen tüm pozitif sayılar elde edilen sıra yok.
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
Salt okunur ve önbelleğe alınan serileri
SEQ.ReadOnly bir sıra salt okunur bir kopyasını oluşturur.Seq.readonlybir dizi gibi bir okuma-yazma koleksiyonu olan ve özgün koleksiyonu değiştirmek istemiyorsanız, yararlıdır.Veri Sarma korumak için bu işlev kullanılabilir.Aşağıdaki kod örneği, bir dizi içeren bir tür oluşturulur.Bir dizi özellik sunar, ancak bir dizi döndürmek yerine, diziden kullanılarak oluşturulan bir dizisini döndürür 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 bir sıra saklı bir sürümünü oluşturur.Kullanmak Seq.cache bir sırası kullanan birden çok iş parçacığı vardır, ancak yalnızca bir kez her öğe sayısı, emin olmanız gerekir, bir sıra veya yeniden değerlendirme önlemek için.Birden çok iş parçacığı tarafından kullanılan sıra varsa, numaralandırır ve özgün sıra değerleri hesaplar bir iş parçacığı olabilir ve önbelleğe alınan sıra diğer iş parçacıkları kullanabilirsiniz.
Sıraları olarak hesaplamaları gerçekleştirme
Basit aritmetik işlemleri listeler, olanlar gibi gibi olan Seq.average, Seq.sum, Seq.averageBy, Seq.sumByve benzeri.
SEQ.fold, Seq.reduce, ve Seq.scan olan listeleri için kullanılamayan ilgili işlevleri gibi.Bu işlevlerin tam değişimleri destek listeleyen alt sıraları destekler.Daha fazla bilgi ve örnekler için bkz, Listeleri (F#).