Partager via


Collections.List, module (F#)

Opérations de base sur les listes.

Espace de noms/Chemin du module : Microsoft.FSharp.Collections

Assembly : FSharp.Core (in FSharp.Core.dll)

module List

Notes

Pour une vue d'ensemble des listes dans F#, consultez Listes (F#).

Valeurs

Valeur

Description

append : 'T list -> 'T list -> 'T list

Retourne une nouvelle liste qui contient les éléments de la première liste suivis des éléments de la seconde.

average : 'T list -> ^T

Retourne la moyenne des éléments de la liste.

averageBy : ('T -> ^U) -> 'T list -> ^U

Retourne la moyenne des éléments générés en appliquant la fonction à chaque élément de la liste.

choose : ('T -> 'U option) -> 'T list -> 'U list

Applique la fonction donnée à chaque élément de la liste. Retourne la liste constituée des résultats pour chaque élément où la fonction retourne Some.

collect : ('T -> 'U list) -> 'T list -> 'U list

Pour chaque élément de la liste, applique la fonction donnée. Concatène tous les résultats et retourne la liste combinée.

concat : seq<'T list> -> 'T list

Retourne une nouvelle liste contenant les éléments de chaque liste dans l'ordre.

empty : 'T list

Retourne une liste vide du type donné.

exists : ('T -> bool) -> 'T list -> bool

Teste si un élément de la liste répond au prédicat donné.

exists2 : ('T1 -> 'T2 -> bool) -> 'T1 list -> 'T2 list -> bool

Teste si une paire d'éléments correspondants des listes répond au prédicat donné.

filter : ('T -> bool) -> 'T list -> 'T list

Retourne une nouvelle collection contenant uniquement les éléments de la collection pour lesquels le prédicat donné retourne la valeur true.

find : ('T -> bool) -> 'T list -> 'T

Retourne le premier élément pour lequel la fonction donnée retourne true.

findIndex : ('T -> bool) -> 'T list -> int

Retourne l'index du premier élément de la liste qui répond au prédicat donné.

fold : ('State -> 'T -> 'State) -> 'State -> 'T list -> 'State

Applique une fonction à chaque élément de la collection, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Cette fonction prend le second argument et applique la fonction spécifiée à celui-ci ainsi qu'au premier élément de la liste. Placez ensuite ce résultat dans la fonction avec le deuxième élément et ainsi de suite. Enfin, elle retourne le résultat final. Si la fonction d'entrée est f et que les éléments sont i0...iN, alors cette fonction calcule f (... (f s i0) i1 ...) iN.

fold2 : ('State -> 'T1 -> 'T2 -> 'State) -> 'State -> 'T1 list -> 'T2 list -> 'State

Applique une fonction aux éléments correspondants de deux collections, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Les collections doivent avoir des tailles identiques. Si la fonction d'entrée est f et que les éléments sont i0...iN et j0...jN, cette fonction calcule alors f (... (f s i0 j0)...) iN jN.

foldBack : ('T -> 'State -> 'State) -> 'T list -> 'State -> 'State

Applique une fonction à chaque élément de la collection, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Si la fonction d'entrée est f et que les éléments sont i0...iN, calcule alors f i0 (...(f iN s)).

foldBack2 : ('T1 -> 'T2 -> 'State -> 'State) -> 'T1 list -> 'T2 list -> 'State -> 'State

Applique une fonction aux éléments correspondants de deux collections, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Les collections doivent avoir des tailles identiques. Si la fonction d'entrée est f et que les éléments sont i0...iN et j0...jN, cette fonction calcule alors f i0 j0 (...(f iN jN s)).

forall : ('T -> bool) -> 'T list -> bool

Teste si tous les éléments de la collection répondent au prédicat donné.

forall2 : ('T1 -> 'T2 -> bool) -> 'T1 list -> 'T2 list -> bool

Teste si tous les éléments correspondants de la collection répondent au prédicat donné par paire.

head : 'T list -> 'T

Retourne le premier élément de la liste.

init : int -> (int -> 'T) -> 'T list

Crée une liste en appelant le générateur donné sur chaque index.

IsEmpty : 'T list -> bool

Retourne la valeur true si la liste ne contient aucun élément ; sinon, retourne la valeur false.

iter : ('T -> unit) -> 'T list -> unit

Applique la fonction donnée à chaque élément de la collection.

iter2 : ('T1 -> 'T2 -> unit) -> 'T1 list -> 'T2 list -> unit

Applique la fonction donnée à deux collections simultanément. Les collections doivent avoir une taille identique.

iteri : (int -> 'T -> unit) -> 'T list -> unit

Applique la fonction donnée à chaque élément de la collection. L'entier passé à la fonction indique l'index de l'élément.

iteri2 : (int -> 'T1 -> 'T2 -> unit) -> 'T1 list -> 'T2 list -> unit

Applique la fonction donnée à deux collections simultanément. Les collections doivent avoir une taille identique. L'entier passé à la fonction indique l'index de l'élément.

length : 'T list -> int

Retourne la longueur de la liste.

map : ('T -> 'U) -> 'T list -> 'U list

Crée une nouvelle collection dont les éléments sont les résultats de l'application de la fonction donnée à chacun des éléments de la collection.

map2 : ('T1 -> 'T2 -> 'U) -> 'T1 list -> 'T2 list -> 'U list

Crée une nouvelle collection dont les éléments sont les résultats de l'application de la fonction donnée aux éléments correspondants des deux collections.

map3 : ('T1 -> 'T2 -> 'T3 -> 'U) -> 'T1 list -> 'T2 list -> 'T3 list -> 'U list

Crée une nouvelle collection dont les éléments sont les résultats de l'application de la fonction donnée aux éléments correspondants des trois collections simultanément.

mapi : (int -> 'T -> 'U) -> 'T list -> 'U list

Crée une nouvelle collection dont les éléments sont les résultats de l'application de la fonction donnée à chacun des éléments de la collection. L'index d'entiers passé à la fonction indique l'index (à partir de 0) de l'élément transformé.

mapi2 : (int -> 'T1 -> 'T2 -> 'U) -> 'T1 list -> 'T2 list -> 'U list

Semblable à List.mapi, mais mappe les éléments correspondants de deux listes de longueur égale.

max : 'T list -> 'T

Retourne le plus grand de tous les éléments de la liste, comparé via Operators.max.

maxBy : ('T -> 'U) -> 'T list -> 'T

Retourne le plus grand de tous les éléments de la liste, comparé via Operators.max avec le résultat de la fonction.

min : 'T list -> 'T

Retourne le plus petit de tous les éléments de la liste, comparé en utilisant Operators.min.

minBy : ('T -> 'U) -> 'T list -> 'T

Retourne le plus petit de tous les éléments de la liste, comparé via Operators.min avec le résultat de la fonction

nth : 'T list -> int -> 'T

Index dans la liste. Le premier élément possède l'index 0.

ofArray : 'T [] -> 'T list

Crée une liste à partir du tableau donné.

ofSeq : seq<'T> -> 'T list

Crée une nouvelle liste à partir de l'objet énumérable donné.

partition : ('T -> bool) -> 'T list * 'T list

Fractionne la collection en deux collections contenant les éléments pour lesquels le prédicat donné retourne respectivement les valeurs true et false.

permute : (int -> int) -> 'T list -> 'T list

Retourne une liste de tous les éléments permutés en fonction de la permutation spécifiée.

pick : ('T -> 'U option) -> 'T list -> 'U

Applique la fonction donnée à des éléments consécutifs, en retournant le premier résultat où la fonction retourne Some pour une valeur.

reduce : ('T -> 'T -> 'T) -> 'T list -> 'T

Applique une fonction à chaque élément de la collection, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Cette fonction applique la fonction spécifiée aux deux premiers éléments de la liste. Elle passe ensuite ce résultat dans la fonction avec le troisième élément et ainsi de suite. Enfin, elle retourne le résultat final. Si la fonction d'entrée est f et que les éléments sont i0...iN, alors cette fonction calcule f (... (f i0 i1) i2 ...) iN.

reduceBack : ('T -> 'T -> 'T) -> 'T list -> 'T

Applique une fonction à chaque élément de la collection, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Si la fonction d'entrée est f et que les éléments sont i0...iN, alors cette fonction calcule f i0 (...(f iN-1 iN)).

replicate : (int -> 'T -> 'T list)

Crée une liste en appelant le générateur donné sur chaque index.

rev : 'T list -> 'T list

Retourne une nouvelle liste avec les éléments dans l'ordre inverse.

scan : ('State -> 'T -> 'State) -> 'State -> 'T list -> 'State list

Applique une fonction à chaque élément de la collection, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Cette fonction prend le second argument et applique la fonction spécifiée à celui-ci ainsi qu'au premier élément de la liste. Placez ensuite ce résultat dans la fonction avec le deuxième élément et ainsi de suite. Enfin, elle retourne la liste des résultats intermédiaires et le résultat final.

scanBack : ('T -> 'State -> 'State) -> 'T list -> 'State -> 'State list

Comme foldBack, mais retourne les résultats intermédiaires et finaux.

sort : 'T list -> 'T list

Trie la liste donnée à l'aide d'Operators.compare.

sortBy : ('T -> 'Key) -> 'T list -> 'T list

Trie la liste donnée à l'aide de clés données par la projection donnée. Les clés sont comparées à l'aide d'Operators.compare.

sortWith : ('T -> 'T -> int) -> 'T list -> 'T list

Trie la liste donnée à l'aide de la fonction de comparaison donnée.

somme : ^T liste -> ^T

Retourne la somme des éléments de la liste.

sumBy : ('T -> ^U) -> 'T list -> ^U

Retourne la somme des résultats générés en appliquant la fonction à chaque élément de la liste.

tail : 'T list -> 'T list

Retourne la liste d'entrée sans le premier élément.

toArray : 'T list -> 'T []

Crée un tableau à partir de la liste donnée.

toSeq : 'T list -> seq<'T>

Affiche la liste donnée sous forme de séquence.

tryFind : ('T -> bool) -> 'T list -> 'T option

Retourne le premier élément pour lequel la fonction donnée retourne true. Retourne None s'il n'existe aucun élément de ce type.

tryFindIndex : ('T -> bool) -> 'T list -> int option

Retourne l'index du premier élément de la liste qui répond au prédicat donné. Retourne None s'il n'existe aucun élément de ce type.

tryPick : ('T -> 'U option) -> 'T list -> 'U option

Applique la fonction donnée à des éléments consécutifs, en retournant le premier résultat où la fonction retourne Some pour une valeur. En l'absence d'élément de ce type, retourne la valeur None.

unzip : ('T1 * 'T2) list -> 'T1 list * 'T2 list

Fractionne une liste de paires en deux listes.

unzip3 : ('T1 * 'T2 * 'T3) list -> 'T1 list * 'T2 list * 'T3 list

Fractionne une liste de triples en trois listes.

zip : 'T1 list -> 'T2 list -> ('T1 * 'T2) list

Combine les deux listes en une liste de paires. Ces deux listes doivent avoir la même longueur.

zip3 : 'T1 list -> 'T2 list -> 'T3 list -> ('T1 * 'T2 * 'T3) list

Combine les trois listes en une liste de triples. Ces trois listes doivent avoir la même longueur.

Plateformes

Windows 7, Windows Vista SP2, Windows XP SP3, Windows XP x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2

Informations de version

Runtime F#

Pris en charge dans : 2.0, 4.0

Silverlight

Prise en charge dans : 3

Voir aussi

Référence

Microsoft.FSharp.Collections, espace de noms (F#)

Autres ressources

Listes (F#)