Listeler (F#)
F #'ta öğeleri aynı türde sıralı, sabit bir dizi listesidir.Listeler temel işlemleri için işlevlerde kullanın listesi Modülü.
Oluşturma ve başlatılıyor listeler
Noktalı virgülle ayırarak ve aşağıdaki kod satırında gösterildiği gibi köşeli parantez içine öğeleri, out açıkça listeleme tarafından bir liste tanımlayabilirsiniz.
let list123 = [ 1; 2; 3 ]
Ayrıca öğeler arasında satır sonu konumuna, bu durumda noktalı virgül isteğe bağlıdır.İkinci sözdizimi öğesi başlatma ifadeler uzun olduğunda ya da her öğe için bir yorum dahil etmek istediğiniz daha okunabilir kodu neden olabilir.
let list123 = [
1
2
3 ]
Normal olarak, tüm liste öğeleri aynı türde olmalıdır.Bir özel durum türetilmiş türlerinin bir listesi öğeleri olan öğeler temel türü olması olabilir belirtilir kullanılır.Şu nedenle kabul edilebilir, çünkü her ikisi de Button ve CheckBox öğesinden türetilen Control.
let myControlList : Control list = [ new Button(); new CheckBox() ]
Aralık işleci tarafından ayrılmış tamsayı tarafından gösterilen bir aralık kullanarak liste öğelerini tanımlayabilirsiniz (..), aşağıdaki kodda gösterildiği gibi.
let list1 = [ 1 .. 10 ]
Aşağıdaki kod olduğu gibi bir döngü yapısı kullanarak, bir liste de tanımlayabilirsiniz.
let listOfSquares = [ for i in 1 .. 10 -> i*i ]
Boş bir liste bir çift köşeli ayraç bunları arasında bir şey ile belirtilir.
// An empty list.
let listEmpty = []
Bir dizi ifadesi, bir listesi oluşturmak için de kullanabilirsiniz."Dizi ifadeleri" bölümüne bakın dizileri.Örneğin, aşağıdaki kod 10'dan 1'den tamsayı kare bir listesini oluşturur.
let squaresList = [ for i in 1 .. 10 -> i * i ]
Listeleri ile çalışmak için işleçler
Liste öğelerini kullanarak ekleyebilirsiniz :: (olumsuz) işleci.Varsa list1 olan [2; 3; 4], aşağıdaki kod oluşturur list2 olarak [100; 2; 3; 4].
let list2 = 100 :: list1
Kullanarak uyumlu türleri olan listeleri art arda @ aşağıdaki kod olduğu gibi işleci.Varsa list1 olan [2; 3; 4] ve list2 olan [100; 2; 3; 4 ], bu kod oluşturur list3 olarak [2; 3; 4; 100; 2; 3; 4].
let list3 = list1 @ list2
İşlevleri listeleri işlemlerini gerçekleştirmek için de kullanılabilir listesi Modülü.
F # listeleri sabit olduğundan, herhangi bir değiştirme işlemi varolan listeleri değiştirmek yerine yeni listeleri oluşturun.
F # listeleri yalnızca listesinin head erişim operations O(1) olduğu anlamına gelir, tek bağlı listeler olarak uygulanır ve öğe erişimi O (n).
Özellikler
Liste türü aşağıdaki özellikleri destekler:
Özellik |
Tür |
Açıklama |
|---|---|---|
'T |
İlk öğe. |
|
'T list |
Bir statik özelliği uygun bir tür boş bir liste döndürür. |
|
bool |
trueListe hiçbir öğe varsa. |
|
'T |
(Sıfır tabanlı) belirtilen dizinindeki öğeyi. |
|
int |
Öğe sayısı. |
|
'T list |
İlk öğe olmadan listesi. |
Aşağıda bu özellikleri kullanarak bazı örnekler verilmiştir.
let list1 = [ 1; 2; 3 ]
// Properties
printfn "list1.IsEmpty is %b" (list1.IsEmpty)
printfn "list1.Length is %d" (list1.Length)
printfn "list1.Head is %d" (list1.Head)
printfn "list1.Tail.Head is %d" (list1.Tail.Head)
printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head)
printfn "list1.Item(1) is %d" (list1.Item(1))
Listelerini kullanma
Programlama listeleriyle karmaşık işlemleri kod küçük miktarda olanak tanır.Bu bölüm için fonksiyonel programlama önemli olan listelerinde genel işlemleri açıklar.
Yineleme listeleriyle
Listeleri için yinelemeli teknikler programlama benzersiz olarak uygundur.Her bir liste öğesi üzerinde gerçekleştirilmesi gereken bir işlem düşünün.Bu yinelemeli olarak listesinin head üzerinde çalışan ve ardından özgün listeyi ilk öğe olmadan oluşan daha küçük bir listesidir listesinin tail yapmak, bir sonraki düzeye özyineleme yeniden.
Bu tür bir özyinelemeli işlev yazmak için eksilerini işlecini kullanın (::) desen eşleştirme içinde sağlayan bir liste başı tail ayırmak.
Aşağıdaki kod örneğinde deseniyle eşleşen bir listesini işlemi gerçekleştiren bir özyinelemeli işlev uygulamak için nasıl kullanılacağını gösterir.
let rec sum list =
match list with
| head :: tail -> head + sum tail
| [] -> 0
Önceki kod küçük listeleri için iyi çalışır, ancak daha büyük listeleri için yığın taşması.Aşağıdaki kod accumulator bağımsız değişken, özyinelemeli işlevleri ile çalışmak için standart bir teknik kullanarak bu kodu artırır.Yığın alanı kaydeder işlevi tail özyinelemeli accumulator bağımsız değişken kullanımını kolaylaştırır.
let sum list =
let rec loop list acc =
match list with
| head :: tail -> loop tail (acc + head)
| [] -> acc
loop list 0
İşlev RemoveAllMultiples iki listesi alan bir özyinelemeli işlev değil.İlk liste ayarlanmış Katlar kaldırılacak sayıları içeren ve sayıları kaldırmak için listeden ikinci listesidir.Aşağıdaki örnek kodda bu özyinelemeli işlev tüm olmayan-üssü sayıları üssü numaralarının listesini sonucu olarak bırakarak bir listeden ortadan kaldırmak için kullanır.
let IsPrimeMultipleTest n x =
x = n || x % n <> 0
let rec RemoveAllMultiples listn listx =
match listn with
| head :: tail -> RemoveAllMultiples tail (List.filter (IsPrimeMultipleTest head) listx)
| [] -> listx
let GetPrimesUpTo n =
let max = int (sqrt (float n))
RemoveAllMultiples [ 2 .. max ] [ 1 .. n ]
printfn "Primes Up To %d:\n %A" 100 (GetPrimesUpTo 100)
Çıkış aşağıdaki gibidir:
Primes Up To 100:
[2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59; 61; 67; 71; 73; 79; 83; 89; 97]
Modül işlevleri
Listesi Modülü bir liste öğelerini erişim işlevleri sağlar.Head öğesi en hızlı ve erişmek kolay adıdır.Özelliğini kullanın Head veya modülü işlevini List.head.Bir liste kuyruğunu kullanarak erişebilirsiniz Tail özelliği veya List.tail işlev.Dizine göre bir öğe bulmak için kullanın List.nth işlev.List.nthListe erişir.Bu nedenle, bu O kadar (n).Kodunuzu kullanıyorsa, List.nth sık, bir dizi listesini yerine kullanmayı isteyebilirsiniz.Öğe dizilerde O(1) erişilebilir.
Listeler üzerinde Boolean işlemleri
List.isEmpty işlevi bir liste herhangi bir öğe olup olmadığını belirler.
List.exists işlevi bir Boolean uygular listesini döndürür ve öğeleri için test true herhangi bir öğeyi test karşılayıp karşılamadığını.List.exists2 benzer ancak iki listelerinde öğeleri art arda gelen çiftlerini çalışır.
Aşağıdaki kod kullanımını gösterir List.exists.
// Use List.exists to determine whether there is an element of a list satisfies a given Boolean expression.
// containsNumber returns true if any of the elements of the supplied list match
// the supplied number.
let containsNumber number list = List.exists (fun elem -> elem = number) list
let list0to3 = [0 .. 3]
printfn "For list %A, contains zero is %b" list0to3 (containsNumber 0 list0to3)
Çıkış aşağıdaki gibidir:
For list [0; 1; 2; 3], contains zero is true
Aşağıdaki örnek kullanımını gösterir List.exists2.
// Use List.exists2 to compare elements in two lists.
// isEqualElement returns true if any elements at the same position in two supplied
// lists match.
let isEqualElement list1 list2 = List.exists2 (fun elem1 elem2 -> elem1 = elem2) list1 list2
let list1to5 = [ 1 .. 5 ]
let list5to1 = [ 5 .. -1 .. 1 ]
if (isEqualElement list1to5 list5to1) then
printfn "Lists %A and %A have at least one equal element at the same position." list1to5 list5to1
else
printfn "Lists %A and %A do not have an equal element at the same position." list1to5 list5to1
Çıkış aşağıdaki gibidir:
Lists [1; 2; 3; 4; 5] and [5; 4; 3; 2; 1] have at least one equal element at the same position.
Kullanabilirsiniz List.forall listesini tüm öğeleri bir koşulu karşılayıp karşılamadığını test etmek istediğiniz.
let isAllZeroes list = List.forall (fun elem -> elem = 0.0) list
printfn "%b" (isAllZeroes [0.0; 0.0])
printfn "%b" (isAllZeroes [0.0; 1.0])
Çıkış aşağıdaki gibidir:
true
false
Benzer şekilde, List.forall2 iki listelerinde karşılık gelen konumlar tüm öğelerin her çiftlerini içeren bir Boolean ifadeyi olup olmadığını belirler.
let listEqual list1 list2 = List.forall2 (fun elem1 elem2 -> elem1 = elem2) list1 list2
printfn "%b" (listEqual [0; 1; 2] [0; 1; 2])
printfn "%b" (listEqual [0; 0; 0] [0; 1; 0])
Çıkış aşağıdaki gibidir:
true
false
Sıralama işlemi listeleri
List.sort, List.sortBy, ve List.sortWith işlevleri sıralama listeler.Sıralama işlevi kullanmak için bu üç işlevlerin belirler.List.sortVarsayılan genel karşılaştırma kullanır.Genel karşılaştırma genel karşılaştırma işlevine dayalı genel işleçler değerleri karşılaştırmak için kullanır.Çok çeşitli gibi basit sayısal türler, başlık, kayıt, ayrılmış birleşimler, liste, dizileri ve uygulayan her türlü öğe türleri ile verimli bir şekilde çalıştığını IComparable.Uygulayan türler için IComparable, genel karşılaştırma kullanır CompareTo işlev.Genel karşılaştırma ayrıca dizeleri ile çalışır, ancak kültür bağımsız bir sıralama düzeni kullanır.Genel karşılaştırma işlev türleri gibi desteklenmeyen türlerinde kullanılmamalıdır.Ayrıca, varsayılan genel karşılaştırma performansını küçük yapılandırılmış türleri için en iyi; Karşılaştırılan ve sık sıralanmış gerek büyük yapılandırılmış türleri için uygulamadan düşünün IComparable ve verimli bir uygulamasını sağlayarak CompareTo yöntemi.
List.sortBySıralama ölçütü olarak kullanılan bir değer döndüren bir işlev alır ve List.sortWith bir karşılaştırma işlevi bağımsız değişken olarak alır.Bu ikinci iki işlevler karşılaştırma desteklemez veya zaman karşılaştırma kültür duyarlı dize durumunda olduğu gibi daha karmaşık karşılaştırma semantiği gerektirir türleri ile çalışırken yararlı olur.
Aşağıdaki örnek kullanımını gösterir List.sort.
let sortedList1 = List.sort [1; 4; 8; -2; 5]
printfn "%A" sortedList1
Çıkış aşağıdaki gibidir:
[-2; 1; 4; 5; 8]
Aşağıdaki örnek kullanımını gösterir List.sortBy.
let sortedList2 = List.sortBy (fun elem -> abs elem) [1; 4; 8; -2; 5]
printfn "%A" sortedList2
Çıkış aşağıdaki gibidir:
[1; -2; 4; 5; 8]
Sonraki örnekte kullanımını gösterir List.sortWith.Bu örnekte, özel karşılaştırma işlevi compareWidgets önce bir alan karşılaştırmak için kullanılan bir özel tür ve ardından başka bir zaman ilk alanı eşit değerleri.
type Widget = { ID: int; Rev: int }
let compareWidgets widget1 widget2 =
if widget1.ID < widget2.ID then -1 else
if widget1.ID > widget2.ID then 1 else
if widget1.Rev < widget2.Rev then -1 else
if widget1.Rev > widget2.Rev then 1 else
0
let listToCompare = [
{ ID = 92; Rev = 1 }
{ ID = 110; Rev = 1 }
{ ID = 100; Rev = 5 }
{ ID = 100; Rev = 2 }
{ ID = 92; Rev = 1 }
]
let sortedWidgetList = List.sortWith compareWidgets listToCompare
printfn "%A" sortedWidgetList
Çıkış aşağıdaki gibidir:
[{ID = 92;
Rev = 1;}; {ID = 92;
Rev = 1;}; {ID = 100;
Rev = 2;}; {ID = 100;
Rev = 5;}; {ID = 110;
Rev = 1;}]
Arama işlemleri listeleri
Çok sayıda arama işlemleri listeleri için desteklenir.Basit, List.find, verilen bir koşul ile eşleşen ilk öğe bulmanızı sağlar.
Aşağıdaki kod örneğinde kullanımını gösterir List.find 5'te bir liste tarafından tam bölünebilir ilk sayı bulmak için.
let isDivisibleBy number elem = elem % number = 0
let result = List.find (isDivisibleBy 5) [ 1 .. 100 ]
printfn "%d " result
Sonucu 5'tir.
İlk öğeleri dönüştürdü, arama List.pick, bir işlev, aldığı bir seçenek döndürür ve ilk seçeneği arar değeri olan Some(x).Öğe döndürüyor yerine List.pick sonucu döndürür x.Eşleşen hiçbir öğe bulunursa, List.pick oluşturur KeyNotFoundException.Aşağıdaki kod kullanımını gösterir List.pick.
let valuesList = [ ("a", 1); ("b", 2); ("c", 3) ]
let resultPick = List.pick (fun elem ->
match elem with
| (value, 2) -> Some value
| _ -> None) valuesList
printfn "%A" resultPick
Çıkış aşağıdaki gibidir:
"b"
Arama işlemi başka bir grup List.tryFind ve ilgili işlevleri, bir seçenek değeri döndürür.List.tryFind İşlevi bu tür bir öğe varsa bir koşula uygun bir liste, ancak seçenek değeri ilk öğe döndürür None değilse.Değişim List.tryFindIndex , öğe yerine bulursa öğenin dizinini döndürür.Bu işlevler aşağıdaki kodda gösterilmiştir.
let list1d = [1; 3; 7; 9; 11; 13; 15; 19; 22; 29; 36]
let isEven x = x % 2 = 0
match List.tryFind isEven list1d with
| Some value -> printfn "The first even value is %d." value
| None -> printfn "There is no even value in the list."
match List.tryFindIndex isEven list1d with
| Some value -> printfn "The first even value is at position %d." value
| None -> printfn "There is no even value in the list."
Çıkış aşağıdaki gibidir:
The first even value is 22.
The first even value is at position 8.
Listelerinde aritmetik işlemler
Toplam ve ortalama gibi ortak aritmetik işlemler yerleşik olarak bulunur listesi Modülü.Çalışmak için List.sum, liste öğesi türü desteklemelidir + işleci ve sıfır değeri.Tüm yerleşik aritmetik türleri bu koşulları karşılayıp.Çalışmak için List.average, öğe türü tamsayısal türleri dışlar ancak sağlar kayan nokta türleri için bir geri kalanı olmadan bölme desteklemesi gerekir.List.sumBy ve List.averageBy işlevleri bir işlev parametresi olarak almaz ve bu işlevin sonuçlarını Topla veya ortalama için değerleri hesaplamak için kullanılır.
Aşağıdaki kod kullanımını gösterir List.sum, List.sumBy, ve List.average.
// Compute the sum of the first 10 integers by using List.sum.
let sum1 = List.sum [1 .. 10]
// Compute the sum of the squares of the elements of a list by using List.sumBy.
let sum2 = List.sumBy (fun elem -> elem*elem) [1 .. 10]
// Compute the average of the elements of a list by using List.average.
let avg1 = List.average [0.0; 1.0; 1.0; 2.0]
printfn "%f" avg1
Çıktı şu şekildedir: 1.000000.
Aşağıdaki kod kullanımını gösterir List.averageBy.
let avg2 = List.averageBy (fun elem -> float elem) [1 .. 10]
printfn "%f" avg2
Çıktı şu şekildedir: 5.5.
Listeler ve diziler
Diziler içeren listeleri ZIP tarafından yönlendirilip yönlendirilemeyeceğini ve işlevleri sıkıştırılmış açma.Bu işlevler tek değer iki listelerini başlık bir liste haline getirme veya bir tanımlama grubu listesi tek değerlerinin iki listeye ayrı.Basit List.zip işlevi iki tek öğeleri listesini alır ve tanımlama grubu çiftleri tek bir listesini oluşturur.Başka bir sürümü List.zip3, üç tek öğeleri listesini alır ve üç öğelerinin başlıkları tek bir listesini oluşturur.Aşağıdaki kod örneğinde kullanımını gösterir List.zip.
let list1 = [ 1; 2; 3 ]
let list2 = [ -1; -2; -3 ]
let listZip = List.zip list1 list2
printfn "%A" listZip
Çıkış aşağıdaki gibidir:
[(1, -1); (2, -2); (3; -3)]
Aşağıdaki kod örneğinde kullanımını gösterir List.zip3.
let list3 = [ 0; 0; 0]
let listZip3 = List.zip3 list1 list2 list3
printfn "%A" listZip3
Çıkış aşağıdaki gibidir:
[(1, -1, 0); (2, -2, 0); (3, -3, 0)]
Sıkıştırılmış açma sürümler, karşılık gelen List.unzip ve List.unzip3, başlık listeleri ve dönüş listeleri burada ilk liste her bir tanımlama grubu ilk tüm öğeleri ve ikinci listenin her bir tanımlama grubu ikinci öğesini içerir, tanımlama grubunda olması ve benzeri.
Aşağıdaki kod örneğinde kullanımını gösterir List.unzip.
let lists = List.unzip [(1,2); (3,4)]
printfn "%A" lists
printfn "%A %A" (fst lists) (snd lists)
Çıkış aşağıdaki gibidir:
([1; 3], [2; 4])
[1; 3] [2; 4]
Aşağıdaki kod örneğinde kullanımını gösterir List.unzip3.
let listsUnzip3 = List.unzip3 [(1,2,3); (4,5,6)]
printfn "%A" listsUnzip3
Çıkış aşağıdaki gibidir:
([1; 4], [2; 5], [3; 6])
Liste öğelerde işletim
F # liste öğelerini işlemlerinin çeşitli destekler.En kolayıdır List.iter, her bir liste öğesi üzerinde bir işlev çağrısı sağlar.Değişkenleri dahil List.iter2, iki liste öğelerini üzerinde bir işlemi etkinleştirir List.iteri, olduğu gibi List.iter her öğenin dizinini her öğe için çağrılan işlevin bağımsız değişken olarak geçirilen dışında ve List.iteri2, işlevselliğini birleşimi olan List.iter2 ve List.iteri.Aşağıdaki kod örneği, bu işlevler gösterir.
let list1 = [1; 2; 3]
let list2 = [4; 5; 6]
List.iter (fun x -> printfn "List.iter: element is %d" x) list1
List.iteri(fun i x -> printfn "List.iteri: element %d is %d" i x) list1
List.iter2 (fun x y -> printfn "List.iter2: elements are %d %d" x y) list1 list2
List.iteri2 (fun i x y ->
printfn "List.iteri2: element %d of list1 is %d element %d of list2 is %d"
i x i y)
list1 list2
Çıkış aşağıdaki gibidir:
List.iter: element is 1
List.iter: element is 2
List.iter: element is 3
List.iteri: element 0 is 1
List.iteri: element 1 is 2
List.iteri: element 2 is 3
List.iter2: elements are 1 4
List.iter2: elements are 2 5
List.iter2: elements are 3 6
List.iteri2: element 0 of list1 is 1; element 0 of list2 is 4
List.iteri2: element 1 of list1 is 2; element 1 of list2 is 5
List.iteri2: element 2 of list1 is 3; element 2 of list2 is 6
Liste öğelerini dönüştüren başka bir sık kullanılan işlev List.map, her bir liste öğesine bir işlevi uygular ve yeni bir listeye tüm sonuçları put sağlar.List.map2 ve List.map3 birden çok listesi olması değişkenleri olan.Ayrıca List.mapi ve List.mapi2, öğe ek olarak, her öğenin dizinini iletilecek işlev gerekiyorsa.Arasındaki tek fark List.mapi2 ve List.mapi olan List.mapi2 iki listeleri ile çalışır.Aşağıdaki örnekte gösterilmektedir List.map.
let list1 = [1; 2; 3]
let newList = List.map (fun x -> x + 1) list1
printfn "%A" newList
Çıkış aşağıdaki gibidir:
[2; 3; 4]
Aşağıdaki örnek, kullanımını gösterir List.map2.
let list1 = [1; 2; 3]
let list2 = [4; 5; 6]
let sumList = List.map2 (fun x y -> x + y) list1 list2
printfn "%A" sumList
Çıkış aşağıdaki gibidir:
[5; 7; 9]
Aşağıdaki örnek, kullanımını gösterir List.map3.
let newList2 = List.map3 (fun x y z -> x + y + z) list1 list2 [2; 3; 4]
printfn "%A" newList2
Çıkış aşağıdaki gibidir:
[7; 10; 13]
Aşağıdaki örnek, kullanımını gösterir List.mapi.
let newListAddIndex = List.mapi (fun i x -> x + i) list1
printfn "%A" newListAddIndex
Çıkış aşağıdaki gibidir:
[1; 3; 5]
Aşağıdaki örnek, kullanımını gösterir List.mapi2.
let listAddTimesIndex = List.mapi2 (fun i x y -> (x + y) * i) list1 list2
printfn "%A" listAddTimesIndex
Çıkış aşağıdaki gibidir:
[0; 7; 18]
List.collect gibidir, List.map, her bir öğe listesini oluşturur ve bu listeler son listesine birleştirilmiş dışında.Aşağıdaki kodda, üç sayı listenin her öğesi oluşturur.Bunlar tüm bir listesine toplanır.
let collectList = List.collect (fun x -> [for i in 1..3 -> x * i]) list1
printfn "%A" collectList
Çıkış aşağıdaki gibidir:
[1; 2; 3; 2; 4; 6; 3; 6; 9]
Ayrıca List.filter, Boolean bir koşul alır ve belirtilen koşulu karşılıyor öğeleri içeren yeni bir listesi oluşturur.
let evenOnlyList = List.filter (fun x -> x % 2 = 0) [1; 2; 3; 4; 5; 6]
Elde edilen listesi [2; 4; 6].
Bir eşleme ve filtre, birleşimi List.choose dönüştürme ve öğeleri aynı anda seçmenize olanak tanır.List.chooseHer bir liste öğesine bir seçenek döndürür ve işlev seçenek değeri döndürdüğünde sonuçları öğeler için yeni bir listesi döndüren bir işlevi uygular Some.
Aşağıdaki kod kullanımını gösterir List.choose sözcükler listesi dışında büyük harfli sözcükleri seçmek için.
let listWords = [ "and"; "Rome"; "Bob"; "apple"; "zebra" ]
let isCapitalized (string1:string) = System.Char.IsUpper string1.[0]
let results = List.choose (fun elem ->
match elem with
| elem when isCapitalized elem -> Some(elem + "'s")
| _ -> None) listWords
printfn "%A" results
Çıkış aşağıdaki gibidir:
["Rome's"; "Bob's"]
Birden çok listelerini işletim
Listeleri birlikte birleştirilebilir.İki liste birine katılmak için kullanın List.append.İkiden fazla listeleri katılmak için kullanın List.concat.
let list1to10 = List.append [1; 2; 3] [4; 5; 6; 7; 8; 9; 10]
let listResult = List.concat [ [1; 2; 3]; [4; 5; 6]; [7; 8; 9] ]
List.iter (fun elem -> printf "%d " elem) list1to10
printfn ""
List.iter (fun elem -> printf "%d " elem) listResult
Katlama ve tarama işlemleri
Bazı listeleme tüm liste öğelerini birbirine içerir.Katlama ve tarama gibi işlemleridir List.iter ve List.map her öğe üzerinde bir işlevi çağırmak, ancak bu işlemleri çağrılır ek bir parametre sağlayan, accumulator , hesaplama bilgilerini taşır.
Kullanım List.fold bir listede bir hesaplama gerçekleştirmek için.
Aşağıdaki kod örneğinde kullanımını gösterir List.fold çeşitli işlemlerini gerçekleştirmek için.
Liste geçirildiği; accumulator acc hesaplama devam ettikçe boyunca geçirilen bir değerdir.İlk bağımsız değişken accumulator ve liste öğesi alır ve bu liste öğesinin hesaplama geçiş sonucunu döndürür.İkinci bağımsız değişkeni accumulator ilk değeri.
let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 3 ] (sumList [ 1 .. 3 ])
// The following example computes the average of a list.
let averageList list = (List.fold (fun acc elem -> acc + float elem) 0.0 list / float list.Length)
// The following example computes the standard deviation of a list.
// The standard deviation is computed by taking the square root of the
// sum of the variances, which are the differences between each value
// and the average.
let stdDevList list =
let avg = averageList list
sqrt (List.fold (fun acc elem -> acc + (float elem - avg) ** 2.0 ) 0.0 list / float list.Length)
let testList listTest =
printfn "List %A average: %f stddev: %f" listTest (averageList listTest) (stdDevList listTest)
testList [1; 1; 1]
testList [1; 2; 1]
testList [1; 2; 3]
// List.fold is the same as to List.iter when the accumulator is not used.
let printList list = List.fold (fun acc elem -> printfn "%A" elem) () list
printList [0.0; 1.0; 2.5; 5.1 ]
// The following example uses List.fold to reverse a list.
// The accumulator starts out as the empty list, and the function uses the cons operator
// to add each successive element to the head of the accumulator list, resulting in a
// reversed form of the list.
let reverseList list = List.fold (fun acc elem -> elem::acc) [] list
printfn "%A" (reverseList [1 .. 10])
Birden fazla listede bir sayı işlev adı olan bu işlevler sürümlerinde çalışır.Örneğin, List.fold2 iki listede hesaplamaları gerçekleştirir.
Aşağıdaki örnek kullanımını gösterir List.fold2.
// Use List.fold2 to perform computations over two lists (of equal size) at the same time.
// Example: Sum the greater element at each list position.
let sumGreatest list1 list2 = List.fold2 (fun acc elem1 elem2 ->
acc + max elem1 elem2) 0 list1 list2
let sum = sumGreatest [1; 2; 3] [3; 2; 1]
printfn "The sum of the greater of each pair of elements in the two lists is %d." sum
List.foldve List.scan farklı List.fold son ek bir parametre değerini döndürür, ancak List.scan (son değer) ile birlikte Orta değerlerin ek parametresinin listesini döndürür.
Örneğin, bu işlevlerin her bir ters değişimi içerir List.foldBack, sırayla farklılık, liste geçirildiği ve bağımsız değişkenler sırasını.Ayrıca, List.fold ve List.foldBack varyasyonları, sahip List.fold2 ve List.foldBack2, iki eşit uzunluğu listesi alır.Her bir öğesinde yürüten işlev, bazı eylemleri gerçekleştirmek için her iki listelerinin karşılık gelen öğeleri kullanabilirsiniz.İki listesi öğe türleri farklı bir liste bir bank hesabı için işlem tamamının içerir aşağıdaki örnekte gösterildiği olabilir ve diğer liste işlem türü içeriyor: havale veya mevzuatı.
// Discriminated union type that encodes the transaction type.
type Transaction =
| Deposit
| Withdrawal
let transactionTypes = [Deposit; Deposit; Withdrawal]
let transactionAmounts = [100.00; 1000.00; 95.00 ]
let initialBalance = 200.00
// Use fold2 to perform a calculation on the list to update the account balance.
let endingBalance = List.fold2 (fun acc elem1 elem2 ->
match elem1 with
| Deposit -> acc + elem2
| Withdrawal -> acc - elem2)
initialBalance
transactionTypes
transactionAmounts
printfn "%f" endingBalance
Toplam gibi bir hesaplama List.fold ve List.foldBack sonucu geçişi sırasına bağlı olmayan çünkü aynı etkisi yoktur.Aşağıdaki örnekte, List.foldBack listedeki öğeleri eklemek için kullanılır.
let sumListBack list = List.foldBack (fun acc elem -> acc + elem) list 0
printfn "%d" (sumListBack [1; 2; 3])
// For a calculation in which the order of traversal is important, fold and foldBack have different
// results. For example, replacing fold with foldBack in the listReverse function
// produces a function that copies the list, rather than reversing it.
let copyList list = List.foldBack (fun elem acc -> elem::acc) list []
printfn "%A" (copyList [1 .. 10])
Aşağıdaki örnek, bank hesabı örneği döndürür.Yeni bir işlem türü eklendiğinde bunu bu süre: ilgi hesaplama.Bitiş bakiyesi şimdi işlemleri sırasına bağlıdır.
type Transaction2 =
| Deposit
| Withdrawal
| Interest
let transactionTypes2 = [Deposit; Deposit; Withdrawal; Interest]
let transactionAmounts2 = [100.00; 1000.00; 95.00; 0.05 / 12.0 ]
let initialBalance2 = 200.00
// Because fold2 processes the lists by starting at the head element,
// the interest is calculated last, on the balance of 1205.00.
let endingBalance2 = List.fold2 (fun acc elem1 elem2 ->
match elem1 with
| Deposit -> acc + elem2
| Withdrawal -> acc - elem2
| Interest -> acc * (1.0 + elem2))
initialBalance2
transactionTypes2
transactionAmounts2
printfn "%f" endingBalance2
// Because foldBack2 processes the lists by starting at end of the list,
// the interest is calculated first, on the balance of only 200.00.
let endingBalance3 = List.foldBack2 (fun elem1 elem2 acc ->
match elem1 with
| Deposit -> acc + elem2
| Withdrawal -> acc - elem2
| Interest -> acc * (1.0 + elem2))
transactionTypes2
transactionAmounts2
initialBalance2
printfn "%f" endingBalance3
İşlev List.reduce biraz gibi olan List.fold ve List.scan, dışında ayrı bir accumulator çevresindeki iletme yerine List.reduce gerçekleştirir öğenin iki bağımsız değişken alan bir işlev yalnızca bir yerine yazın ve bunu Ara hesaplama sonucu depolar anlamına accumulator, bu bağımsız değişkenlerden biri davranır.List.reduceilk iki listesi öğelerde işletim tarafından başlatır ve sonra sonraki öğe birlikte işleminin sonucu kullanır.Kendi türüne sahip bir ayrı accumulator olmadığından List.reduce yerine kullanılan List.fold yalnızca olduğunda accumulator ve öğe türü aynı türüne sahip.Aşağıdaki kod kullanımını gösterir List.reduce.List.reducesağlanan listesini hiçbir öğe varsa bir özel durum oluşturur.
Aşağıdaki kod, ilk çağrıda lambda ifadesi bağımsız değişkenler 2 ve 4 verilen ve 6 döndürür ve sonraki arama sonucu 16 olacak şekilde 6 ve 10, bağımsız değişkenler verilir.
let sumAList list =
try
List.reduce (fun acc elem -> acc + elem) list
with
| :? System.ArgumentException as exc -> 0
let resultSum = sumAList [2; 4; 10]
printfn "%d " resultSum
Listeleri ve diğer koleksiyon türü arasında dönüştürme
List Modül hem gelen dizileri ve diziler dönüştürmek için işlevler sağlar.İçin veya bir serisinden dönüştürmek için kullanın List.toSeq veya List.ofSeq.İçin veya bir dizideki dönüştürmek için kullanın List.toArray veya List.ofArray.
Ek işlemleri
Listelerinde ek işlemleri hakkında daha fazla bilgi için Kitaplığı Başvurusu konusuna Collections.List Modülü (F#).