Esporta (0) Stampa
Espandi tutto
Espandi Riduci a icona
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

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

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.

exactlyOne : seq<'T> -> 'T

Restituisce il solo elemento della sequenza.

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 una nuova raccolta contenente i soli elementi della raccolta 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 della raccolta, eseguendo il threading di un argomento di 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 delle sequenze è più breve dell'altra, gli elementi restanti della sequenza più lunga verranno 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 della raccolta.

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

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

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

Applica la funzione specificata a ogni elemento della raccolta. L'Integer passato alla funzione indica l'indice dell'elemento.

last : seq<'T> -> 'T

Restituisce l'ultimo elemento della sequenza.

length : seq<'T> -> int

Restituisce la lunghezza della sequenza.

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

Crea una nuova raccolta i cui elementi sono il risultato ottenuto applicando la funzione specificata a ogni elemento della raccolta. 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 una nuova raccolta 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 una nuova raccolta i cui elementi sono il risultato ottenuto applicando la funzione specificata a ogni elemento della raccolta. 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 nella raccolta.

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

Visualizza la matrice specificata come una 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 accumulatore nel 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 dalla raccolta fornita.

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

Consente di creare un elenco dalla raccolta fornita.

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.

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

Restituisce una nuova raccolta contenente i soli elementi della raccolta per cui il predicato specificato restituisce true. Sinonimo Seq.filter.

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 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

Versioni della libreria di base F#

Supportato in: 2,0, 4,0, portabile

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft