Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Modulo Collections.List (F#)
Collapse the table of content
Expand the table of content
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Modulo Collections.List (F#)

Operazioni di base sugli elenchi.

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

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

module List

Per una panoramica degli elenchi in F#, vedere Elenchi (F#).

Valore

Descrizione

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

Restituisce un nuovo elenco contenente gli elementi del primo elenco seguiti dagli elementi del secondo elenco.

average : 'T list -> ^T

Restituisce la media degli elementi nell'elenco.

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

Restituisce la media degli elementi generati applicando la funzione a ogni elemento dell'elenco.

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

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 -> 'U list) -> 'T list -> 'U list

Per ogni elemento dell'elenco applica la funzione specificata. Concatena tutti i risultati e restituisce l'elenco combinato.

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

Restituisce un nuovo elenco contenente gli elementi di ogni elenco nello stesso ordine.

empty : 'T list

Restituisce un elenco vuoto del tipo specificato.

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

Verifica se eventuali elementi dell'elemento soddisfano il predicato specificato.

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

Verifica se una qualsiasi coppia di elementi corrispondenti degli elenchi soddisfa il predicato specificato.

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

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

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

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

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

Restituisce l'indice del primo elemento nell'elenco che soddisfa il predicato specificato.

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

Applica una funzione a ogni elemento della raccolta, eseguendo il threading di un argomento di accumulatore attraverso il calcolo. Questa funzione utilizza il secondo argomento e applica la funzione a questo e al primo elemento dell'elenco. Il risultato viene quindi passato alla funzione insieme al secondo elemento e così via. Infine, restituisce il risultato finale. Se la funzione di input è f e gli elementi sono i0...iN, tale funzione calcola f (... (f s i0) i1 ...) iN.

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

Applica una funzione agli elementi corrispondenti di due raccolte, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Le dimensioni delle raccolte devono coincidere. Se la funzione di input è f e gli elementi sono i0...iN e j0...jN, tale funzione calcola f (... (f s i0 j0)...) iN jN.

foldBack : ('T -> 'State -> 'State) -> 'T list -> 'State -> '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, calcola f i0 (...(f iN s)).

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

Applica una funzione agli elementi corrispondenti di due raccolte, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Le dimensioni delle raccolte devono coincidere. Se la funzione di input è f e gli elementi sono i0...iN e j0...jN, tale funzione calcola f i0 j0 (...(f iN jN s)).

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

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

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

Verifica se tutti gli elementi corrispondenti della raccolta soddisfano a coppie il predicato specificato.

head : 'T list -> 'T

Restituisce il primo elemento dell'elenco.

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

Crea un elenco chiamando il generatore specificato per ogni indice.

isEmpty : 'T list -> bool

Restituisce true se l'elenco non contiene elementi, false in caso contrario.

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

Applica la funzione specificata a ogni elemento della raccolta.

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

Applica la funzione specificata a due raccolte contemporaneamente. Le dimensioni delle raccolte devono essere identiche.

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

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

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

Applica la funzione specificata a due raccolte contemporaneamente. Le dimensioni delle raccolte devono essere identiche. L'Integer passato alla funzione indica l'indice dell'elemento.

length : 'T list -> int

Restituisce la lunghezza dell'elenco.

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

Crea una nuova raccolta i cui elementi sono il risultato ottenuto applicando la funzione specificata a ogni elemento della raccolta.

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

Crea una nuova raccolta i cui elementi sono il risultato ottenuto applicando la funzione specificata agli elementi corrispondenti delle due raccolte a coppie.

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

Crea una nuova raccolta i cui elementi sono il risultato ottenuto applicando la funzione specificata agli elementi corrispondenti delle tre raccolte contemporaneamente.

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

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.

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

Come List.mapi, ma esegue il mapping degli elementi corrispondenti da due elenchi di uguale lunghezza.

max : 'T list -> 'T

Restituisce il maggiore di tutti gli elementi dell'elenco, confrontato utilizzando Operators.max.

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

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

min : 'T list -> 'T

Restituisce il minore di tutti gli elementi dell'elenco, confrontato tramite Operators.min.

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

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

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

Determina l'indicizzazione nell'elenco. Il primo elemento ha indice 0.

ofArray : 'T [] -> 'T list

Consente di creare un elenco dalla matrice fornita.

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

Crea un nuovo elenco dall'oggetto enumerabile specificato.

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

Divide la raccolta specificata in due raccolte contenenti rispettivamente gli elementi per cui il predicato specificato restituisce true e false

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

Restituisce un elenco con tutti gli elementi permutati secondo la permutazione specificata.

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

Applica la funzione specificata a elementi consecutivi, restituendo il primo risultato in cui la funzione restituisce Some per alcuni valori.

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

Applica una funzione a ogni elemento della raccolta, eseguendo il threading di un argomento di accumulatore attraverso il calcolo. Questa funzione applica la funzione specificata ai primi due elementi dell'elenco. Quindi immette il risultato di questa esecuzione nella funzione insieme al terzo elemento e così via. Infine, restituisce il risultato finale. Se la funzione di input è f e gli elementi sono i0...iN, tale funzione calcola f (... (f i0 i1) i2 ...) iN.

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

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 i0 (...(f iN-1 iN)).

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

Crea un elenco chiamando il generatore specificato per ogni indice.

rev : 'T list -> 'T list

Restituisce un nuovo elenco con gli elementi in ordine inverso.

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

Applica una funzione a ogni elemento della raccolta, eseguendo il threading di un argomento di accumulatore attraverso il calcolo. Questa funzione utilizza il secondo argomento e applica la funzione specificata a questo e al primo elemento dell'elenco. Il risultato viene quindi passato alla funzione insieme al secondo elemento e così via. Infine, vengono restituiti l'elenco di risultati intermedi e il risultato finale.

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

Analogo a foldBack, ma restituisce sia i risultati intermedi che quelli finali

sort : 'T list -> 'T list

Ordina l'elenco specificato tramite Operators.compare.

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

Ordina l'elenco specificato utilizzando chiavi fornite dalla proiezione specificata. Le chiavi vengono confrontate mediante Operators.compare.

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

Ordina l'elenco specificato utilizzando la funzione di confronto indicata.

sum : ^T list -> ^T

Restituisce la somma degli elementi nell'elenco.

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

Restituisce la somma dei risultati generati applicando la funzione a ogni elemento dell'elenco.

tail : 'T list -> 'T list

Restituisce l'elenco di input senza il primo elemento.

toArray : 'T list -> 'T []

Consente di creare una matrice dall'elenco specificato.

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

Visualizza l'elenco specificato come sequenza.

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

Restituisce il primo elemento per cui la funzione specificata restituisce true. Se l'elemento non esiste, restituisce None.

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

Restituisce l'indice del primo elemento nell'elenco che soddisfa il predicato specificato. Se l'elemento non esiste, restituisce None.

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

Applica la funzione specificata a elementi consecutivi, restituendo il primo risultato in cui la funzione restituisce Some per alcuni valori. Se l'elemento non esiste, restituisce None.

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

Suddivide un elenco di coppie in due elenchi.

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

Divide un elenco di triple in tre elenchi.

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

Combina i due elenchi in un elenco di coppie. Le lunghezze dei due elenchi devono coincidere.

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

Combina i tre elenchi in un elenco di tripli. Le lunghezze degli elenchi devono coincidere.

Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

Versioni della libreria di base F#

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

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:
© 2015 Microsoft