Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese
Questa documentazione è stata archiviata e non viene gestita.

Modulo Collections.Seq (F#)

Operazioni di base su sequenze enumerabili.

Percorso di spazio dei nomi/modulo: Microsoft.FSharp.Collections

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

module Seq

Per una panoramica delle sequenze in F#, vedere Sequenze (F#).

Valore

Oggetto di descrizione

append : seq<'T> -> seq<'T> -> seq<'T>

Esegue il wrapping delle due enumerazioni specificate come singola enumerazione concatenata.

average : seq<^T> -> ^T

Restituisce la media degli elementi nella sequenza.

averageBy : ('T -> ^U) -> seq<'T> -> ^U

Restituisce la media dei risultati generati applicando la funzione a ogni elemento della sequenza.

cache : seq<'T> -> seq<'T>

Restituisce una sequenza che corrisponde a una versione memorizzata nella cache della sequenza di input.

cast : IEnumerable -> seq<'T>

Esegue il wrapping di una sequenza System.Collections non fortemente tipizzata come sequenza tipizzata.

choose : ('T -> 'U option) -> seq<'T> -> seq<'U>

Applica la funzione specificata a ogni elemento dell'elenco. Restituisce l'elenco comprensivo dei risultati per ogni elemento in cui la funzione restituisce Some.

collect : ('T -> 'Collection) -> seq<'T> -> seq<'U>

Applica la funzione specificata a ogni elemento della sequenza e concatena tutti i risultati.

compareWith : ('T -> 'T -> int) -> seq<'T> -> seq<'T> -> int

Confronta due sequenze utilizzando la funzione di confronto specificata, elemento per elemento.

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

Combina l'enumerazione di enumerazioni specificata come singola enumerazione concatenata.

countBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * int>

Applica una funzione di generazione chiavi a ogni elemento di una sequenza e restituisce una sequenza che produce chiavi univoche e il relativo numero di occorrenze nella sequenza originale.

delay : (unit -> seq<'T>) -> seq<'T>

Restituisce una sequenza compilata a partire dalla specifica ritardata indicata di una sequenza.

distinct : seq<'T> -> seq<'T>

Restituisce una sequenza che non contiene voci duplicate in base all'hash generico e ai confronti di uguaglianze nelle voci. Se un elemento è presente più volte nella sequenza, le occorrenze successive vengono ignorate.

distinctBy : ('T -> 'Key) -> seq<'T> -> seq<'T>

Restituisce una sequenza che non contiene voci duplicate in base all'hash generico e ai confronti di uguaglianze nelle chiavi restituite dalla funzione di generazione chiavi specificata. Se un elemento è presente più volte nella sequenza, le occorrenze successive vengono ignorate.

empty : seq<'T>

Crea una sequenza vuota.

exists : ('T -> bool) -> seq<'T> -> bool

Verifica se un qualsiasi elemento della sequenza soddisfa il predicato specificato.

exists2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool

Verifica se una qualsiasi coppia di elementi corrispondenti delle sequenze di input soddisfa il predicato specificato.

filter : ('T -> bool) -> seq<'T> -> seq<'T>

Restituisce un nuovo insieme contenente i soli elementi dell'insieme per cui il predicato specificato restituisce true.

find : ('T -> bool) -> seq<'T> -> 'T

Restituisce il primo elemento per cui la funzione specificata restituisce true.

findIndex : ('T -> bool) -> seq<'T> -> int

Restituisce l'indice del primo elemento per cui la funzione specificata restituisce true.

fold : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> 'State

Applica una funzione a ogni elemento dell'insieme, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi sono i0...iN,, tale funzione calcola f (... (f s i0)...) iN.

forall : ('T -> bool) -> seq<'T> -> bool

Verifica se tutti gli elementi della sequenza soddisfano il predicato specificato.

forall2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool

Verifica se tutte le coppie di elementi individuate a partire dalle due sequenze soddisfano il predicato specificato. Se una sequenza è più breve dell'altra, gli elementi restanti della sequenza più lunga vengono ignorati.

groupBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * seq<'T>>

Applica una funzione di generazione chiavi a ogni elemento di una sequenza e produce una sequenza di chiavi univoche. Ogni chiave univoca contiene inoltre una sequenza di tutti gli elementi corrispondenti a questa chiave.

head : seq<'T> -> 'T

Restituisce il primo elemento della sequenza.

init : int -> (int -> 'T) -> seq<'T>

Genera una nuova sequenza che, se iterata, restituisce elementi successivi chiamando la funzione specificata, fino al conteggio indicato. I risultati della chiamata alla funzione non vengono salvati, ovvero la funzione verrà applicata di nuovo, se necessario, per rigenerare gli elementi. Alla funzione viene passato l'indice dell'elemento in corso di generazione.

initInfinite : (int -> 'T) -> seq<'T>

Genera una nuova sequenza che, se iterata, restituirà elementi successivi chiamando la funzione specificata. I risultati della chiamata alla funzione non vengono salvati, ovvero la funzione verrà applicata di nuovo, se necessario, per rigenerare gli elementi. Alla funzione viene passato l'indice dell'elemento in corso di generazione.

isEmpty : seq<'T> -> bool

Verifica se una sequenza contiene elementi.

iter : ('T -> unit) -> seq<'T> -> unit

Applica la funzione specificata a ogni elemento dell'insieme.

iter2 : ('T1 -> 'T2 -> unit) -> seq<'T1> -> seq<'T2> -> unit

Applica la funzione specificata a due insiemi contemporaneamente. Se una sequenza è più breve dell'altra, gli elementi restanti della sequenza più lunga vengono ignorati.

iteri : (int -> 'T -> unit) -> seq<'T> -> unit

Applica la funzione specificata a ogni elemento dell'insieme. Il numero intero passato alla funzione indica l'indice dell'elemento.

length : seq<'T> -> int

Restituisce la lunghezza della sequenza.

map : ('T -> 'U) -> seq<'T> -> seq<'U>

Crea un nuovo insieme i cui elementi sono il risultato ottenuto applicando la funzione specificata a ogni elemento dell'insieme. La funzione specificata verrà applicata nel momento in cui gli elementi vengono richiesti mediante il metodo MoveNext negli enumeratori recuperati dall'oggetto.

map2 : ('T1 -> 'T2 -> 'U) -> seq<'T1> -> seq<'T2> -> seq<'U>

Crea un nuovo insieme i cui elementi sono il risultato dell'applicazione della funzione specificata alle coppie corrispondenti di elementi delle due sequenze. Se una sequenza di input è più breve dell'altra, gli elementi restanti della sequenza più lunga verranno ignorati.

mapi : (int -> 'T -> 'U) -> seq<'T> -> seq<'U>

Crea un nuovo insieme i cui elementi sono il risultato ottenuto applicando la funzione specificata a ogni elemento dell'insieme. L'indice Integer passato alla funzione indica l'indice (da 0) dell'elemento in corso di trasformazione.

max : seq<'T> -> 'T

Restituisce il maggiore di tutti gli elementi della sequenza, confrontato utilizzando Operators.max.

maxBy : ('T -> 'U) -> seq<'T> -> 'T

Restituisce il maggiore di tutti gli elementi della sequenza, confrontato utilizzando Operators.max nel risultato della funzione.

min : seq<'T> -> 'T

Restituisce il minore di tutti gli elementi della sequenza, confrontato tramite Operators.min.

minBy : ('T -> 'U) -> seq<'T> -> 'T

Restituisce il minore di tutti gli elementi della sequenza, confrontato utilizzando Operators.min nel risultato della funzione.

nth : int -> seq<'T> -> 'T

Calcola l'ennesimo elemento nell'insieme.

ofArray : 'T array -> seq<'T>

Visualizza la matrice specificata come sequenza.

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

Visualizza l'elenco specificato come sequenza.

pairwise : seq<'T> -> seq<'T * 'T>

Restituisce una sequenza di ogni elemento nella sequenza di input e il relativo predecessore, ad eccezione del primo elemento che viene restituito esclusivamente come predecessore del secondo elemento.

pick : ('T -> 'U option) -> seq<'T> -> 'U

Applica la funzione specificata a elementi consecutivi, restituendo il primo valore in cui la funzione restituisce un valore Some.

readonly : seq<'T> -> seq<'T>

Crea un nuovo oggetto sequenza che delega all'oggetto sequenza specificato. In questo modo la sequenza originale non può essere nuovamente individuata e modificata da un cast di tipo. Ad esempio, per una specifica matrice la sequenza restituita restituirà gli elementi della matrice, ma non sarà possibile eseguire il cast dell'oggetto sequenza restituito a una matrice.

reduce : ('T -> 'T -> 'T) -> seq<'T> -> 'T

Applica una funzione a ogni elemento della sequenza, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Inizia applicando la funzione ai primi due elementi. Quindi immette il risultato di questa esecuzione nella funzione insieme al terzo elemento e così via. Restituisce il risultato finale.

scan : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> seq<'State>

Come Seq.fold, ma calcola su richiesta e restituisce la sequenza di risultati intermedi e finali.

singleton : 'T -> seq<'T>

Restituisce una sequenza che produce un solo elemento.

skip : int -> seq<'T> -> seq<'T>

Restituisce una sequenza che ignora un numero specificato di elementi della sequenza sottostante e restituisce gli elementi rimanenti della sequenza.

skipWhile : ('T -> bool) -> seq<'T> -> seq<'T>

Restituisce una sequenza che, se iterata, ignora gli elementi della sequenza sottostante mentre il predicato specificato restituisce true e produce quindi gli elementi rimanenti della sequenza.

sort : seq<'T> -> seq<'T>

Produce una sequenza ordinata in base alle chiavi.

sortBy : ('T -> 'Key) -> seq<'T> -> seq<'T>

Applica una funzione di generazione chiavi a ogni elemento di una sequenza e produce una sequenza ordinata in base alle chiavi. Le chiavi vengono confrontate utilizzando il confronto generico implementato da Operators.compare.

sum : seq<^T> -> ^T

Restituisce la somma degli elementi nella sequenza.

sumBy

Restituisce la somma dei risultati generati applicando la funzione a ogni elemento della sequenza.

take : int -> seq<'T> -> seq<'T>

Restituisce i primi elementi della sequenza fino a un conteggio specificato.

takeWhile : ('T -> bool) -> seq<'T> -> seq<'T>

Restituisce una sequenza che, se iterata, produce gli elementi della sequenza sottostante mentre il predicato specificato restituisce true e non restituisce quindi alcun altro elemento.

toArray : seq<'T> -> 'T []

Consente di creare una matrice dall'insieme fornito.

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

Consente di creare un elenco dall'insieme fornito.

truncate : int -> seq<'T> -> seq<'T>

Restituisce una sequenza che, se enumerata, restituisce non più di un numero specificato di elementi.

tryFind : ('T -> bool) -> seq<'T> -> 'T option

Restituisce il primo elemento per cui la funzione specificata restituisce true o None se tale elemento non esiste.

tryFindIndex : ('T -> bool) -> seq<'T> -> int option

Restituisce l'indice del primo elemento della sequenza che soddisfa il predicato specificato o None se un tale elemento non esiste.

tryPick : ('T -> 'U option) -> seq<'T> -> 'U option

Applica la funzione specificata a elementi consecutivi, restituendo il primo valore in cui la funzione restituisce un valore Some.

unfold : ('State -> 'T * 'State option) -> 'State -> seq<'T>

Restituisce una sequenza che contiene gli elementi generati dal calcolo specificato.

windowed : int -> seq<'T> -> seq<'T []>

Restituisce una sequenza che produce finestre scorrevoli di elementi contenitori ricavati dalla sequenza di input. Ogni finestra viene restituita come matrice aggiornata.

zip : seq<'T1> -> seq<'T2> -> seq<'T1 * 'T2>

Combina le due sequenze in un elenco di coppie. Non è necessario che le due sequenze siano di pari lunghezza: all'esaurimento di una sequenza, gli eventuali elementi rimanenti dell'altra verranno ignorati.

zip3 : seq<'T1> -> seq<'T2> -> seq<'T3> -> seq<'T1 * 'T2 * 'T3>

Combina le tre sequenze in un elenco di tripli. Non è necessario che le sequenze siano di pari lunghezza: all'esaurimento di una sequenza, gli eventuali elementi rimanenti dell'altra verranno ignorati.

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

F# Runtime

Supportato in: 2.0, 4.0

Silverlight

Supportato in: 3

Mostra: