Espressioni lambda: parola chiave fun (F#)

La fun parola chiave viene usata per definire un'espressione lambda, ovvero una funzione anonima.

Sintassi

fun parameter-list -> expression

In alternativa, usare la _.Property notazione abbreviata:

_.

fun, parameter-list e lambda arrow (->) vengono omessi e fa parte dell'espressione_. in cui _ sostituisce il simbolo del parametro.

I frammenti di codice seguenti sono equivalenti:

(fun x -> x.Property) _.Property

Osservazioni:

L'elenco di parametri è in genere costituito da nomi e, facoltativamente, tipi di parametri. Più in generale, l'elenco di parametri può essere composto da qualsiasi modello F#. Per un elenco completo dei possibili modelli, vedere Criteri di ricerca. Gli elenchi di parametri validi includono gli esempi seguenti.

// Lambda expressions with parameter lists.
fun a b c -> ...
fun (a: int) b c -> ...
fun (a : int) (b : string) (c:float) -> ...

// A lambda expression with a tuple pattern.
fun (a, b) -> …

// A lambda expression with a cons pattern.
// (note that this will generate an incomplete pattern match warning)
fun (head :: tail) -> …

// A lambda expression with a list pattern.
// (note that this will generate an incomplete pattern match warning)
fun [_; rest] -> …

L'espressione è il corpo della funzione, l'ultima espressione di che genera un valore restituito. Esempi di espressioni lambda valide sono i seguenti:

fun x -> x + 1
fun a b c -> printfn "%A %A %A" a b c
fun (a: int) (b: int) (c: int) -> a + b * c
fun x y -> let swap (a, b) = (b, a) in swap (x, y)

Uso di espressioni lambda

Le espressioni lambda sono particolarmente utili quando si desidera eseguire operazioni in un elenco o in un'altra raccolta e si vuole evitare il lavoro aggiuntivo di definizione di una funzione. Molte funzioni della libreria F# accettano valori di funzione come argomenti e possono essere particolarmente utili per usare un'espressione lambda in questi casi. Il codice seguente applica un'espressione lambda agli elementi di un elenco. In questo caso, la funzione anonima controlla se un elemento è testo che termina con caratteri specificati.

let fullNotation = [ "a"; "ab"; "abc" ] |> List.find ( fun text -> text.EndsWith("c") )
printfn "%A" fullNotation         // Output: "abc"

let shorthandNotation = [ "a"; "ab"; "abc" ] |> List.find ( _.EndsWith("b") )
printfn "%A" shorthandNotation    // Output: "ab"

Il frammento di codice precedente mostra entrambe le notazioni: usando la fun parola chiave e la notazione abbreviata _.Property .

Vedere anche

• Funzioni