Seznamy (F#)

V F# seznam je uspořádaný, neměnná řadou prvků stejného typu.

Vytvoření a inicializace seznamy

Seznam můžete definovat seznam explicitně prvky oddělené středníky a uzavřena v hranatých závorkách, jak je znázorněno v následujícím řádku kódu.

let list123 = [ 1; 2; 3 ]

Můžete také vložit konce řádků mezi prvky, v takovém případě jsou volitelné středníky.Tato syntaxe může způsobit kód čitelnější při inicializaci výrazy prvku jsou delší nebo chcete zahrnout komentáře pro každý prvek.

let list123 = [
    1
    2
    3 ]

Všechny prvky seznamu normálně, musí být stejného typu.Výjimkou je, že seznam, ve kterém jsou uvedeny prvky být základní typ může obsahovat prvky, které jsou odvozené typy.Proto je přijatelné, protože obě Button a CheckBox odvodit z Control.

let myControlList : Control list = [ new Button(); new CheckBox() ]

Prvky seznamu můžete také definovat pomocí rozsahu označeny celá čísla odděleny operátor range (..), jak je znázorněno v následujícím kódu.

let list1 = [ 1 .. 10 ]

Můžete také definovat seznam pomocí opakování konstrukce, jako v následujícím kódu.

let listOfSquares = [ for i in 1 .. 10 -> i*i ]

Prázdný seznam je určen dvojici hranatých závorek se nic mezi nimi.

// An empty list.
let listEmpty = []

Výraz sekvence můžete také vytvořit seznam.Viz "Sekvence výrazů" v sekvence.Například následující kód vytvoří seznam čtverců celá čísla od 1 do 10.

let squaresList = [ for i in 1 .. 10 -> i * i ]

Operátory pro práci se seznamy

Prvky můžete do seznamu připojit pomocí :: operátor (nevýhody).If list1 is [2; 3; 4], the following code creates list2 as [100; 2; 3; 4].

let list2 = 100 :: list1

Můžete zřetězit seznamy, které mají kompatibilní typy pomocí @ operátor jako v následujícím kódu.If list1 is [2; 3; 4] and list2 is [100; 2; 3; 4 ], this code creates list3 as [2; 3; 4; 100; 2; 3; 4].

let list3 = list1 @ list2

Funkce pro provádění operací seznamy jsou k dispozici v seznam modulu.

Seznamy v F# jsou nezměnitelné, jakékoli změny operací generovat nové seznamy namísto změně existujících seznamů.

Seznamy v F# jsou implementovány jako jednotlivě propojených seznamů, které znamená, že operace, které přístup hlavy seznamu O(1), a přístup prvek je O (n).

Vlastnosti

Typ seznamu podporuje následující vlastnosti:

Property	Type	Description
Hlava	'T	První prvek.
Prázdné	'T list	Statická vlastnost, která vrátí prázdný seznam příslušného typu.
IsEmpty	bool	truePokud v seznamu nemá žádné prvky.
Položka	'T	Prvek v zadaném indexu (od nuly).
Délka	int	Počet prvků.
Ocáskem	'T list	Bez první prvek seznamu.

Následuje několik příkladů použití těchto vlastností.

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))

Použití seznamů

Programování se seznamy lze provádět složité operace s malou část kódu.Tato část popisuje běžné operace na seznamech, které jsou důležité pro funkční programování.

Rekurze se seznamy

Seznamy jsou jedinečně hodí pro rekurzivní programovací techniky.Zvažte operaci, která musí být provedena na každý prvek seznamu.Můžete to tento rekurzivně na hlavy v seznamu a potom předáním ocasu seznam, který je menší seznam, který se skládá z původního seznamu bez první prvek, zpět na další úroveň rekurze.

Chcete-li napsat rekurzivní funkce, použijte operátor nevýhody (::) v porovnávání, která umožňuje oddělit od ocasu hlavy seznam.

Následující příklad kódu ukazuje, jak použít masku provádět rekurzivní funkce, která provádí operace v seznamu.

let rec sum list =
   match list with
   | head :: tail -> head + sum tail
   | [] -> 0

Předchozí kód funguje dobře pro malé seznamy, ale pro větší seznamy ji nelze přetečení zásobníku.Následující kód vylepšuje tento kód pomocí argumentu akumulátor, standardní postup pro práci s rekurzivní funkce.Použití argumentu akumulátorová provádí rekurzivní funkce ocasu, což šetří místo zásobníku.

let sum list =
   let rec loop list acc =
       match list with
       | head :: tail -> loop tail (acc + head)
       | [] -> acc
   loop list 0

Funkce RemoveAllMultiples je rekurzivní funkci, která trvá dva seznamy.První seznam obsahuje čísla, jejichž násobků budou odebrány a druhý seznam je seznam, ze kterého chcete odstranit čísla.Kód v následujícím příkladu používá rekurzivní funkce vyloučit všechny non primárního čísla ze seznamu seznam prvočísel ponechat jako výsledek.

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)

Výstup je následující:

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]

Funkce modulu

Seznam modulu poskytuje funkce, které prvky seznamu přístup.Head element je nejrychlejší a nejjednodušší přístup.Vlastnost hlavy nebo funkce modulu List.head.Zadní část Seznam můžete přistupovat pomocí ocasu vlastnost nebo List.tail funkce.Pomocí indexu vyhledat prvek, List.nth funkce.List.nthpropojení seznamu.Proto je O (n).Pokud váš kód používá List.nth často, je vhodné zvážit použití pole místo seznamu.Prvek přístup v polích je O(1).

Logická operace v seznamech

List.isEmpty funkce určuje, zda má seznam všech prvků.

List.exists funkce použije Boolean zkoušky na prvky seznamu a vrátí true Pokud jakýkoli prvek splňuje test.List.exists2 je podobné, ale pracuje na sobě dvojice prvků ve dvou seznamech.

Následující kód ukazuje použití 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)

Výstup je následující:

For list [0; 1; 2; 3], contains zero is true

Následující příklad ukazuje použití 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

Výstup je následující:

Lists [1; 2; 3; 4; 5] and [5; 4; 3; 2; 1] have at least one equal element at the same position.

Můžete použít List.forall Pokud chcete otestovat, zda prvky seznamu splňují podmínku.

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])

Výstup je následující:

true
false

Podobně List.forall2 Určuje, zda splňují všechny prvky na odpovídající pozici ve dvou seznamech logický výraz, který zahrnuje každé dvojice prvků.

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])

Výstup je následující:

true
false

Operace řazení seznamů

List.sort, List.sortBy, a List.sortWith funkce řazení seznamů.Funkci třídění určuje, které tyto tři funkce používat.List.sortpoužívá výchozí obecný porovnání.Obecný porovnání používá globální hospodářské subjekty na základě obecného porovnat funkce porovnávání hodnot.Efektivně pracuje s různými typy prvků, jako jsou například jednoduché typy číselných, n-tic, záznamy, discriminated sdružení, seznamy, pole a libovolného typu, který implementuje IComparable.Pro typy této implementace IComparable, používá obecný porovnání CompareTo funkce.Obecný porovnání také spolupracuje s řetězci, ale použije pořadí řazení nezávislé kultury.Obecný srovnání by nepoužívá nepodporované typy, například typy funkce.Také výchozí obecný porovnání výkonu je nejvhodnější pro malé strukturované typů; pro větší strukturované typy, které je třeba často seřazeny a porovnání, implementace IComparable a zajištění účinného provádění CompareTo metoda.

List.sortBypřevezme funkci, která vrací hodnotu, která je použit jako kritérium řazení a List.sortWith trvá porovnání funkci jako argument.Tyto posledně dvě funkce jsou užitečné při práci s typy nepodporují porovnání nebo při porovnání vyžaduje složitější porovnání sémantiku, jako v případě kultura podporující řetězce.

Následující příklad ukazuje použití List.sort.

let sortedList1 = List.sort [1; 4; 8; -2; 5]
printfn "%A" sortedList1

Výstup je následující:

[-2; 1; 4; 5; 8]

Následující příklad ukazuje použití List.sortBy.

let sortedList2 = List.sortBy (fun elem -> abs elem) [1; 4; 8; -2; 5]
printfn "%A" sortedList2

Výstup je následující:

[1; -2; 4; 5; 8]

Následující příklad ukazuje použití List.sortWith.V tomto příkladu funkce porovnání vlastní compareWidgets se používá k porovnání nejprve jedno pole vlastní typ a potom jiného při shodné hodnoty prvního pole.

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

Výstup je následující:

  [{ID = 92;
    Rev = 1;}; {ID = 92;
                Rev = 1;}; {ID = 100;
                            Rev = 2;}; {ID = 100;
                                        Rev = 5;}; {ID = 110;
                                                    Rev = 1;}]

Operace hledání v seznamech

Mnoho operací hledání jsou podporovány pro seznamy.Nejjednodušší, List.find, umožňuje vyhledat první prvek, který odpovídá dané podmínce.

Následující příklad kódu ukazuje použití List.find první číslo dělitelné 5 v seznamu najít.

let isDivisibleBy number elem = elem % number = 0
let result = List.find (isDivisibleBy 5) [ 1 .. 100 ]
printfn "%d " result

Výsledkem je 5.

Prvky musí nejdříve transformovat, kontaktujte List.pick, který převezme funkci, vrátí možnost a hledá první možnost Hodnota, která je Some(x).Namísto vrácení prvku, List.pick vrátí výsledek x.Pokud není nalezen, List.pick vyvolá KeyNotFoundException.Následující kód ukazuje použití 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

Výstup je následující:

"b"

Jiné skupiny vyhledávací operace List.tryFind a související funkce vrátí hodnotu možnosti.List.tryFind Funkce vrátí první prvek seznamu, který splňuje podmínku, pokud takový prvek existuje, ale hodnota možnosti None Pokud není.Změna List.tryFindIndex vrátí index prvku, pokud najde, spíše než prvek sám.Tyto funkce jsou znázorněny v následujícím kódu.

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."

Výstup je následující:

The first even value is 22.
The first even value is at position 8.

Aritmetické operace s seznamy

Jsou součástí běžné aritmetické operace, například součet a průměr seznam modulu.Práce s List.sum, musí podporovat typ prvku seznamu + operátor a mít hodnotu nula.Všechny předdefinované typy aritmetické splňovat tyto podmínky.Práce s List.average, typ prvku musí podporovat dělení beze zbytku, které vylučuje typů, ale umožňuje pro plovoucí typy.List.sumBy a List.averageBy funkce využít funkci jako parametr a výsledky této funkce se používají k výpočtu hodnoty pro součet nebo průměr.

Následující kód ukazuje použití List.sum, List.sumBy, a 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

Výstup je 1.000000.

Následující kód ukazuje použití List.averageBy.

let avg2 = List.averageBy (fun elem -> float elem) [1 .. 10]
printfn "%f" avg2

Výstup je 5.5.

Seznamy a n-tice

Seznamy, které obsahují n-tic, se kterým zip a unzip funkce.Tyto funkce sloučit dva seznamy jedné hodnoty do jednoho seznamu n-tic nebo rozdělit jeden seznam řazená do dva seznamy jedné hodnoty.Nejjednodušší List.zip funkce dva seznamy jednotlivé prvky a vytváří jeden seznam dvojic n-tice.Jiná verze List.zip3, trvá tři seznamy jednotlivé prvky a vytvoří jediný seznam záznamů, které mají tři prvky.Následující příklad kódu ukazuje použití List.zip.

let list1 = [ 1; 2; 3 ]
let list2 = [ -1; -2; -3 ]
let listZip = List.zip list1 list2
printfn "%A" listZip

Výstup je následující:

[(1, -1); (2, -2); (3; -3)]

Následující příklad kódu ukazuje použití List.zip3.

let list3 = [ 0; 0; 0]
let listZip3 = List.zip3 list1 list2 list3
printfn "%A" listZip3

Výstup je následující:

[(1, -1, 0); (2, -2, 0); (3, -3, 0)]

Odpovídající unzip verze, List.unzip a List.unzip3, seznamy n-tic a vratky seznamy v n-tice, kde první seznam obsahuje všechny prvky, které byly poprvé každého záznamu a druhý seznam obsahuje druhého prvku každého záznamu a tak dále.

Následující příklad kódu ukazuje použití List.unzip.

let lists = List.unzip [(1,2); (3,4)]
printfn "%A" lists
printfn "%A %A" (fst lists) (snd lists)

Výstup je následující:

([1; 3], [2; 4])
[1; 3] [2; 4]

Následující příklad kódu ukazuje použití List.unzip3.

let listsUnzip3 = List.unzip3 [(1,2,3); (4,5,6)]
printfn "%A" listsUnzip3

Výstup je následující:

([1; 4], [2; 5], [3; 6])

V seznamu prvků

F# podporuje řadu operací na prvky seznamu.Nejjednodušší je List.iter, který umožňuje volání funkce na každý prvek seznamu.Zahrnovat varianty List.iter2, který umožňuje provádět operace na prvky dva seznamy List.iteri, který je jako List.iter s výjimkou, že index každý prvek je předáno jako argument funkce, která se nazývá pro každý prvek a List.iteri2, což je kombinace funkcí List.iter2 a List.iteri.Následující příklad kódu ukazuje tyto funkce.

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

Výstup je následující:

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

Jiné často používané funkce, který transformuje prvky seznamu je List.map, který můžete použít funkci pro každý prvek seznamu a všechny výsledky do nového seznamu.List.map2 a List.map3 jsou varianty, které více seznamů.Můžete také použít List.mapi a List.mapi2, pokud je vedle elementu, funkce musí předat index každý prvek.Jediný rozdíl mezi List.mapi2 a List.mapi je List.mapi2 pracuje se dvěma seznamy.Následující příklad ukazuje List.map.

let list1 = [1; 2; 3]
let newList = List.map (fun x -> x + 1) list1
printfn "%A" newList

Výstup je následující:

[2; 3; 4]

Následující příklad ukazuje použití 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

Výstup je následující:

[5; 7; 9]

Následující příklad ukazuje použití List.map3.

let newList2 = List.map3 (fun x y z -> x + y + z) list1 list2 [2; 3; 4]
printfn "%A" newList2

Výstup je následující:

[7; 10; 13]

Následující příklad ukazuje použití List.mapi.

let newListAddIndex = List.mapi (fun i x -> x + i) list1
printfn "%A" newListAddIndex

Výstup je následující:

[1; 3; 5]

Následující příklad ukazuje použití List.mapi2.

let listAddTimesIndex = List.mapi2 (fun i x y -> (x + y) * i) list1 list2
printfn "%A" listAddTimesIndex

Výstup je následující:

[0; 7; 18]

List.Collect jako List.map, s výjimkou, že každý prvek vytvoří seznam a tyto seznamy jsou zřetězeny do konečného seznamu.Následující kód vygeneruje každý prvek seznamu tři čísla.Všechny jsou shromážděny do jednoho seznamu.

let collectList = List.collect (fun x -> [for i in 1..3 -> x * i]) list1
printfn "%A" collectList

Výstup je následující:

[1; 2; 3; 2; 4; 6; 3; 6; 9]

Můžete také použít List.filter, který trvá logickou podmínkou a vytváří nový seznam, který obsahuje pouze prvky, které splňují určité podmínky.

let evenOnlyList = List.filter (fun x -> x % 2 = 0) [1; 2; 3; 4; 5; 6]

Výsledný seznam je [2; 4; 6].

Kombinace mapy a filtr List.choose umožňuje transformovat a vyberte prvky současně.List.choosepoužije funkci, která vrátí možnost každému prvku seznam a vrátí nový seznam výsledků pro prvky při vrátí hodnotu možnost Some.

Následující kód ukazuje použití List.choose vyberte velkými písmeny slova seznam slov.

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

Výstup je následující:

["Rome's"; "Bob's"]

Na více seznamů

Seznamy mohou být spojeny.Chcete-li spojit dva seznamy do jednoho, použijte List.append.Chcete-li připojit více než dva seznamy použijte 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

Skládání a prohledávání

Některé operace seznam zahrnuje vzájemné závislosti mezi všechny prvky seznamu.Skládání a kontroly operací jsou jako List.iter a List.map že vyvolat funkci na každý prvek, ale tyto operace poskytnout další parametr, nazývá akumulátorové , přenáší informace prostřednictvím výpočtu.

Použití List.fold provedení výpočtu na seznamu.

Následující příklad kódu ukazuje použití List.fold k provádění různých operací.

Je seznam vyčerpán; akumulátor acc je hodnota, která je předán společně, jak probíhá výpočet.První argument akumulátoru a prvek seznamu a vrátí prozatímní výsledek výpočtu pro daný prvek seznamu.Druhý argument je počáteční hodnota akumulátoru.

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])

Verze těchto funkcí, které obsahují číslice v názvu funkce pracují více než jeden seznam.Například List.fold2 provádí výpočty dva seznamy.

Následující příklad ukazuje použití 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.folda List.scan se liší, List.fold vrátí konečnou hodnotu parametr navíc, ale List.scan vrátí seznam mezilehlé hodnoty dodatečný parametr (spolu s konečnou hodnotu).

Každá z těchto funkcí obsahuje zpětné variantu, například List.foldBack, která se liší v pořadí, v které je seznam vyčerpán a pořadí argumentů.Také List.fold a List.foldBack mají varianty, List.fold2 a List.foldBack2, který přijme dva seznamy stejné délky.Funkce, která se provede na každý prvek lze provádět některé akce odpovídající prvky obou seznamech.Typy prvků dva seznamy mohou být různé, jako v následujícím příkladu, ve kterém jeden seznam obsahuje částky transakce pro bankovní účet a další seznam obsahuje typ transakce: uložení nebo zrušení.

// 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

Pro výpočet jako SUMA List.fold a List.foldBack mají stejný účinek, protože výsledek nezávisí ze křížovou kontrolu.V následujícím příkladu List.foldBack slouží k přidávání prvků v seznamu.

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])

Následující příklad vrátí například bankovní účet.Tento čas je přidán nový typ transakce: výpočtu úroku.Konečné saldo je nyní závisí ze transakce.

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

Funkce List.reduce je něco jako List.fold a List.scan, s výjimkou, že namísto předávání kolem samostatného akumulátoru, List.reduce trvá funkce, která používá dva argumenty prvku, zadejte namísto jen jeden a jeden z těchto argumentů jako akumulátoru, což uchovává zprostředkující výsledek výpočtu.List.reducezačne na první dva seznam prvků a potom použije výsledek operace spolu s další prvek.Protože není samostatné akumulátor, který má své vlastní typ List.reduce lze použít místo List.fold pouze při akumulátoru a typ prvku mají stejného typu.Následující kód ukazuje použití List.reduce.List.reducevyvolá výjimku, pokud seznamu nemá žádné prvky.

V následujícím kódu první volání lambda výraz je dán argumenty, 2 a 4 a 6 vrátí a další volání je dán argumenty, 6 a 10, takže výsledek je 16.

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

Převod mezi seznamy a další typy kolekce

List Modul obsahuje funkce pro převod ze sekvence a matice.Převod do nebo z posloupnosti, použijte List.toSeq nebo List.ofSeq.Chcete-li převést na matici, použijte List.toArray nebo List.ofArray.

Další operace

Informace o dalších operacích v seznamech naleznete v tématu referenční knihovny Collections.list modul (F#).

Viz také

Referenční dokumentace

Sekvence (F#)

Možnosti (F#)

Další zdroje

F# Language Reference

Typy F#

Matice (F#)