Modulo Collections.Seq (F#)

average : seq<^T> -> ^T

Restituisce la media degli elementi nella sequenza.

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

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

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.

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

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

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.

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.

empty : seq<'T>

Crea una sequenza vuota.

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.

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

Restituisce il 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.

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.

head : seq<'T> -> 'T

Restituisce il primo elemento della sequenza.

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.

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

Applica la funzione specificata a ogni elemento dell'insieme.

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.

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.

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.

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

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

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

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

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

Visualizza la matrice specificata 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.

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.

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.

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.

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

Produce una sequenza ordinata in base alle chiavi.

sum : seq<^T> -> ^T

Restituisce la somma degli elementi nella sequenza.

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

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

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

Consente di creare una matrice dall'insieme fornito.

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

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

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.

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

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

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.