Collections.Seq, module (F#)
Opérations de base sur les séquences énumérables.
Espace de noms/Chemin du module : Microsoft.FSharp.Collections
Assembly : FSharp.Core (in FSharp.Core.dll)
module Seq
Notes
Pour une vue d'ensemble des séquences dans F#, consultez Séquences (F#).
Valeurs
Valeur |
Description |
|---|---|
append : seq<'T> -> seq<'T> -> seq<'T> |
Encapsule les deux énumérations données en une énumération concaténée unique. |
average : seq<^T> -> ^T |
Retourne la moyenne des éléments dans la séquence. |
averageBy : ('T -> ^U) -> seq<'T> -> ^U |
Retourne la moyenne des résultats générés en appliquant la fonction à chaque élément de la séquence. |
cache : seq<'T> -> seq<'T> |
Retourne une séquence qui correspond à une version mise en cache de la séquence d'entrée. |
cast : IEnumerable -> seq<'T> |
Encapsule une séquence peu typée System.Collections sous forme de séquence typée. |
choose : ('T -> 'U option) -> seq<'T> -> seq<'U> |
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 -> 'Collection) -> seq<'T> -> seq<'U> |
Applique la fonction donnée à chaque élément de la séquence et concatène tous les résultats. |
compareWith : ('T -> 'T -> int) -> seq<'T> -> seq<'T> -> int |
Compare deux séquences à l'aide de la fonction de comparaison donnée, élément par élément. |
concat : seq<'Collection> -> seq<'T> |
Combine l'énumération d'énumérations donnée en une énumération concaténée unique. |
countBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * int> |
Applique une fonction génératrice de clé à chaque élément d'une séquence et retourne une séquence qui produit des clés uniques et leur nombre d'occurrences dans la séquence d'origine. |
delay : (unit -> seq<'T>) -> seq<'T> |
Retourne une séquence générée à partir de la spécification différée donnée d'une séquence. |
distinct : seq<'T> -> seq<'T> |
Retourne une séquence qui ne contient pas d'entrées en double conformément aux comparaisons de hachage et d'égalité génériques sur les entrées.Si un élément apparaît plusieurs fois dans la séquence, les occurrences ultérieures sont ignorées. |
distinctBy : ('T -> 'Key) -> seq<'T> -> seq<'T> |
Retourne une séquence qui ne contient aucune entrée en double conformément aux comparaisons de hachage et d'égalité génériques sur les clés retournées par la fonction génératrice de clé donnée.Si un élément apparaît plusieurs fois dans la séquence, les occurrences ultérieures sont ignorées. |
empty : seq<'T> |
Crée une séquence vide. |
exactlyOne: seq<'T> -> 'T |
Retourne le seul élément de la séquence. |
exists : ('T -> bool) -> seq<'T> -> bool |
Teste si tous les éléments de la séquence répondent au prédicat donné. |
exists2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool |
Teste si une paire d'éléments correspondants des séquences d'entrée répond au prédicat donné. |
filter : ('T -> bool) -> seq<'T> -> seq<'T> |
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) -> seq<'T> -> 'T |
Retourne le premier élément pour lequel la fonction donnée retourne true. |
findIndex : ('T -> bool) -> seq<'T> -> int |
Retourne l'index du premier élément pour lequel la fonction donnée retourne la valeur true. |
fold : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> '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,, cette fonction calcule alors f (... (f s i0)...) iN. |
forall : ('T -> bool) -> seq<'T> -> bool |
Teste si tous les éléments de la séquence répondent au prédicat donné. |
forall2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool |
Teste si toutes les paires d'éléments qui proviennent des deux séquences répondent au prédicat donné.Si une séquence est plus courte que l'autre, les éléments restants de la séquence la plus longue sont ignorés. |
groupBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * seq<'T>> |
Applique une fonction génératrice de clé à chaque élément d'une séquence et produit une séquence de clés uniques.Chaque clé unique contient également une séquence de tous les éléments qui correspondent à cette clé. |
head : seq<'T> -> 'T |
Retourne le premier élément de la séquence. |
init : int -> (int -> 'T) -> seq<'T> |
Génère une nouvelle séquence qui, si elle est itérée, retourne des éléments consécutifs en appelant la fonction donnée, jusqu'au nombre donné.Les résultats de l'appel de la fonction ne sont pas enregistrés ; en d'autres termes, la fonction est réappliquée chaque fois que nécessaire pour régénérer les éléments.L'index de l'élément actuellement généré est passé à la fonction. |
initInfinite : (int -> 'T) -> seq<'T> |
Génère une nouvelle séquence qui, si elle est itérée, retournera des éléments consécutifs en appelant la fonction donnée.Les résultats de l'appel de la fonction ne seront pas enregistrés ; en d'autres termes, la fonction sera réappliquée chaque fois que nécessaire pour régénérer les éléments.L'index de l'élément actuellement généré est passé à la fonction. |
IsEmpty : seq<'T> -> bool |
Teste si une séquence contient des éléments. |
iter : ('T -> unit) -> seq<'T> -> unit |
Applique la fonction donnée à chaque élément de la collection. |
iter2 : ('T1 -> 'T2 -> unit) -> seq<'T1> -> seq<'T2> -> unit |
Applique la fonction donnée à deux collections simultanément.Si une séquence est plus courte que l'autre, les éléments restants de la séquence la plus longue sont ignorés. |
iteri : (int -> 'T -> unit) -> seq<'T> -> unit |
Applique la fonction donnée à chaque élément de la collection.L'entier passé à la fonction indique l'index de l'élément. |
last : seq<'T> -> 'T |
Retourne le dernier élément de la séquence. |
length : seq<'T> -> int |
Retourne la longueur de la séquence |
map : ('T -> 'U) -> seq<'T> -> seq<'U> |
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.La fonction donnée sera appliquée sur les énumérateurs extraits de l'objet lorsque les éléments seront demandés à l'aide de la méthode MoveNext. |
map2 : ('T1 -> 'T2 -> 'U) -> seq<'T1> -> seq<'T2> -> seq<'U> |
Crée une nouvelle collection dont les éléments sont les résultats de l'application de la fonction donnée aux paires d'éléments correspondantes des deux séquences.Si une séquence d'entrée est plus courte que l'autre, les éléments restants de la séquence la plus longue sont ignorés. |
mapi : (int -> 'T -> 'U) -> seq<'T> -> seq<'U> |
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é. |
max : seq<'T> -> 'T |
Retourne le plus grand de tous les éléments de la séquence, comparé en utilisant Operators.max. |
maxBy : ('T -> 'U) -> seq<'T> -> 'T |
Retourne le plus grand de tous les éléments de la séquence, comparé via Operators.max avec le résultat de la fonction. |
min : seq<'T> -> 'T |
Retourne le plus petit de tous les éléments de la séquence, comparé en utilisant Operators.min. |
minBy : ('T -> 'U) -> seq<'T> -> 'T |
Retourne le plus petit de tous les éléments de la séquence, comparé via Operators.min avec le résultat de la fonction. |
nth : int -> seq<'T> -> 'T |
Calcule le nième élément dans la collection. |
ofArray : 'T array -> seq<'T> |
Affiche le tableau donné sous forme de séquence. |
ofList : 'T list -> seq<'T> |
Affiche la liste donnée sous forme de séquence. |
pairwise : seq<'T> -> seq<'T * 'T> |
Retourne une séquence de chaque élément dans la séquence d'entrée et son prédécesseur, à l'exception du premier élément qui est uniquement retourné comme prédécesseur du deuxième élément. |
pick : ('T -> 'U option) -> seq<'T> -> 'U |
Applique la fonction donnée à des éléments consécutifs, en retournant la première valeur où la fonction retourne une valeur Some. |
readonly : seq<'T> -> seq<'T> |
Crée un nouvel objet de séquence qui délègue à l'objet de séquence donné.Cette action garantit que la séquence d'origine ne peut pas être redécouverte et subir de mutation par un cast de type.Par exemple, étant donné un tableau spécifique, la séquence retournée retournera les éléments de ce tableau, mais vous ne pourrez pas effectuer un cast de l'objet de séquence retourné en un tableau. |
reduce : ('T -> 'T -> 'T) -> seq<'T> -> 'T |
Applique une fonction à chaque élément de la séquence, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul.Commencez en appliquant la fonction aux deux premiers éléments.Placez ensuite ce résultat dans la fonction avec le troisième élément et ainsi de suite.Retourne le résultat final. |
scan : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> seq<'State> |
Semblable à Seq.fold, mais calcule à la demande et retourne la séquence de résultats intermédiaires et finaux. |
singleton : 'T -> seq<'T> |
Retourne une séquence qui produit uniquement un élément. |
skip : int -> seq<'T> -> seq<'T> |
Retourne une séquence qui ignore un nombre spécifié d'éléments de la séquence sous-jacente, puis produit les éléments restants de la séquence. |
skipWhile : ('T -> bool) -> seq<'T> -> seq<'T> |
Retourne une séquence qui, lorsqu'elle est itérée, ignore les éléments de la séquence sous-jacente lorsque le prédicat donné retourne la valeur true, puis produit les éléments restants de la séquence. |
sort : seq<'T> -> seq<'T> |
Produit une séquence classée en fonction des clés. |
sortBy: ('T -> 'Key) -> seq<'T> -> seq<'T> |
Applique une fonction génératrice de clé à chaque élément d'une séquence et produit une séquence classée en fonction des clés.Les touches sont comparées à l'aide de la comparaison générique telle qu'elle est implémentée par Operators.compare. |
sum : seq<^T> -> ^T |
Retourne la somme des éléments dans la séquence. |
Retourne la somme des résultats générés en appliquant la fonction à chaque élément de la séquence. |
|
take : int -> seq<'T> -> seq<'T> |
Retourne les premiers éléments de la séquence jusqu'à un nombre spécifié. |
takeWhile : ('T -> bool) -> seq<'T> -> seq<'T> |
Retourne une séquence qui, lorsqu'elle est itérée, produit les éléments de la séquence sous-jacente lorsque le prédicat donné retourne la valeur true, puis ne retourne aucun autre élément. |
toArray : seq<'T> -> 'T [] |
Crée un tableau à partir de la collection donnée. |
toList : seq<'T> -> 'T list |
Crée une liste à partir de la collection donnée. |
truncate : int -> seq<'T> -> seq<'T> |
Retourne une séquence qui, si énumérée, retourne pas plus qu'un nombre spécifié d'éléments. |
tryFind : ('T -> bool) -> seq<'T> -> 'T option |
Retourne le premier élément pour lequel la fonction donnée retourne true ou None si aucun élément de ce type n'existe. |
tryFindIndex : ('T -> bool) -> seq<'T> -> int option |
Retourne l'index du premier élément de la séquence qui répond au prédicat donné ou None si aucun élément de ce type n'existe. |
tryPick : ('T -> 'U option) -> seq<'T> -> 'U option |
Applique la fonction donnée à des éléments consécutifs, en retournant la première valeur où la fonction retourne une valeur Some. |
unfold : ('State -> 'T * 'State option) -> 'State -> seq<'T> |
Retourne une séquence qui contient les éléments générés par le calcul donné. |
où : ('T -> bool) -> seq<'T> -> seq<'T> |
Retourne une nouvelle collection contenant uniquement les éléments de la collection pour lesquels le prédicat donné retourne la valeur true.Un synonyme pour Seq.filter. |
windowed : int -> seq<'T> -> seq<'T []> |
Retourne une séquence qui produit des fenêtres défilantes d'éléments conteneurs provenant de la séquence d'entrée.Chaque fenêtre est retournée sous la forme d'un nouveau tableau. |
zip : seq<'T1> -> seq<'T2> -> seq<'T1 * 'T2> |
Combine les deux séquences dans une liste de paires.Il n'est pas nécessaire que les deux séquences aient la même longueur : lorsque la fin d'une séquence est atteinte, les éléments restants dans l'autre séquence sont ignorés. |
zip3 : seq<'T1> -> seq<'T2> -> seq<'T3> -> seq<'T1 * 'T2 * 'T3> |
Combine les trois séquences en une liste de triples.Il n'est pas nécessaire que les séquences aient la même longueur : lorsque la fin d'une séquence est atteinte, les éléments restants dans les autres séquences sont ignorés. |
Plateformes
Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2
Informations de version
Versions de bibliothèque principale F#
Prise en charge dans : 2,0, 4,0, portables