Differenza tra let, fun e function in F #

Question

Sto imparando F # e non riesco a capire quale sia la differenza tra let, fun e function, e il mio libro di testo non lo spiega davvero. Per fare un esempio:

let s sym = function 
| V x -> Map.containsKey x sym 
| A(f, es) -> Map.containsKey f sym && List.forall (s sym) es;; 

non potrei avere scritto questo senza la parola chiave function? O potrei averlo scritto con fun invece di function? E perché devo scrivere let quando ho visto alcuni esempi in cui si scrive

fun s x = 
... 

Qual è la differenza davvero?

Answer 1

Credo che si dovrebbe davvero chiedere MSDN, ma in poche parole:

let lega un valore con un simbolo. Il valore può essere un tipo semplice come int o string, ma può anche essere una funzione. Nelle funzioni FP sono valori e possono essere trattati allo stesso modo di quei tipi.

fun è una parola chiave che introduce una funzione anonima: si pensi all'espressione lambda se si ha familiarità con C#.

Questi sono i due più importanti, nel senso che tutti gli altri usi che hai visto possono essere pensati come zucchero sintattico per quei due. Quindi per definire una funzione, puoi dire qualcosa del tipo:

let myFunction = 
    fun firstArg secondArg -> 
     someOperation firstArg secondArg 

E questo è un modo molto chiaro per dirlo. Dichiari di avere una funzione e quindi associalo al simbolo myFunction.

Ma si può risparmiare un po 'di battitura, semplicemente una confusione dichiarazione di funzione anonima e vincolante in un simbolo con let:

let myFunction firstArg secondArg = 
    someOperation firstArg secondArg 

Cosa function fa è un po' più complicato - si combinano un dichiarazione di funzione singolo argomento anonimo con un'espressione match, facendo corrispondere un argomento implicito. Quindi, questi due sono equivalenti:

let myFunction firstArg secondArg = 
    match secondArg with 
    | "foo" -> firstArg 
    | x -> x 

let myFunction firstArg = function 
    | "foo" -> firstArg 
    | x -> x  

Se si sta appena iniziando su F #, mi piacerebbe larga da quello. Ha i suoi usi (principalmente per fornire succinte funzioni di ordine superiore per mappe/filtri ecc.), Ma risulta in codice meno leggibile a colpo d'occhio.

Answer 2

Queste cose sono una specie di scorciatoie l'una con l'altra.

La cosa fondamentale è let. Questa parola chiave dà un nome alle cose:

let name = "stuff" 

parlando più tecnicamente, la parola chiave let definisce un identificatore e lo associa a un valore:

let identifier = "value" 

Dopo questo, è possibile utilizzare le parole name e identifier nella vostra programma, e il compilatore saprà cosa significano.Senza lo let, non ci sarebbe un modo per nominare le cose, e dovresti sempre scrivere tutte le tue cose in linea, invece di riferirti a pezzi di esso per nome.

Ora, i valori sono disponibili in diversi gusti. Ci sono stringhe "some string", ci sono numeri interi 42, numeri in virgola mobile 5.3, valori booleani true e così via. Su un tipo speciale di valore è la funzione . Le funzioni sono anche valori, per molti aspetti simili a stringhe e numeri. Ma come si scrive una funzione? Per scrivere una stringa, si usano le virgolette doppie, ma per quanto riguarda la funzione?

Beh, di scrivere una funzione, si utilizza la parola speciale fun:

let squareFn = fun x -> x*x 

Qui, ho usato la parola chiave let per definire un identificatore squareFn, e si legano che identificativo per un valore del tipo di funzione. Ora posso usare la parola squareFn nel mio programma, e il compilatore saprà che ogni volta che lo uso intendo una funzione fun x -> x*x.

Questa sintassi è tecnicamente sufficiente, ma non sempre comoda per scrivere. Quindi, al fine di renderlo più breve, il let legame assume una responsabilità in più su se stesso e fornisce un modo più breve di scrivere quanto sopra:

let squareFn x = x*x 

Questo dovrebbe farlo per let vs fun.

Ora, la parola chiave function è solo una forma breve per fun + match. Scrivere function equivale a scrivere fun x -> match x with, punto.

Ad esempio, i seguenti tre definizioni sono equivalenti:

let f = fun x -> 
    match x with 
    | 0 -> "Zero" 
    | _ -> "Not zero" 

let f x = // Using the extra convenient form of "let", as discussed above 
    match x with 
    | 0 -> "Zero" 
    | _ -> "Not zero" 

let f = function // Using "function" instead of "fun" + "match" 
    | 0 -> "Zero" 
    | _ -> "Not zero"