Associazioni let (F#)
Un'associazione associa un identificatore a un valore o a una funzione. È possibile utilizzare la parola chiave let per associare un nome a un valore o a una funzione.
// Binding a value:
let identifier-or-pattern [: type] =
expression
body-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =
expression
body-expression
Note
La parola chiave let viene utilizzata nelle espressioni di associazione per definire valori o valori di funzione per uno o più nomi. La forma più semplice dell'espressione let consente di associare un nome a un valore semplice, come illustrato di seguito.
let i = 1
Se si separa l'espressione dall'identificatore utilizzando una nuova riga, è necessario impostare un rientro per ogni riga dell'espressione, come nel codice seguente.
let someVeryLongIdentifier =
// Note indentation below.
3 * 4 + 5 * 6
Anziché specificare solo un nome, è possibile specificare un modello contenente nomi, ad esempio una tupla, come illustrato nel codice seguente.
let i, j, k = (1, 2, 3)
body-expression è l'espressione in cui vengono utilizzati i nomi. L'espressione del corpo appare da sola su una riga, con un rientro impostato in modo da allinearla esattamente con il primo carattere della parola chiave let:
let result =
let i, j, k = (1, 2, 3)
// Body expression:
i + 2*j + 3*k
Un'associazione let può essere presente a livello di modulo, nella definizione di un tipo di classe o in ambiti locali, ad esempio una definizione di funzione. Un'associazione let al livello principale in un modulo o in un tipo di classe non deve necessariamente disporre di un'espressione del corpo, che è però richiesta agli altri livelli di ambito. I nomi associati possono essere utilizzati dopo il punto di definizione, ma non in qualsiasi punto prima dell'associazione let, come illustrato nel codice seguente.
// Error:
printfn "%d" x
let x = 100
// OK:
printfn "%d" x
Associazioni di funzioni
Le associazioni di funzioni seguono le regole per le associazioni di valori, ad eccezione del fatto che le associazioni di funzioni includono il nome e i parametri della funzione, come illustrato nel codice seguente.
let function1 a =
a + 1
In generale, i parametri sono modelli, come ad esempio un modello tupla:
let function2 (a, b) = a + b
Un'espressione di associazione let restituisce il valore dell'ultima espressione. Nell'esempio di codice seguente, pertanto, il valore di result viene calcolato da 100 * function3 (1, 2), che restituisce 300.
let result =
let function3 (a, b) = a + b
100 * function3 (1, 2)
Annotazioni di tipi
È possibile specificare tipi per i parametri includendo i due punti (:) seguiti da un nome di tipo, il tutto racchiuso tra parentesi. È anche possibile specificare il tipo del valore restituito aggiungendo i due punti e il tipo dopo l'ultimo parametro. Le annotazioni di tipo complete per function1, con numeri interi come tipi di parametro, sono simili a quanto indicato di seguito.
let function1 (a: int) : int = a + 1
Quando non vi sono parametri di tipo espliciti, viene utilizzata l'inferenza del tipo per determinare i tipi di parametri delle funzioni. Questo può includere la generalizzazione automatica del tipo di un parametro, in modo da impostarlo come generico.
Per ulteriori informazioni, vedere Generalizzazione automatica (F#) e Inferenza del tipo (F#).
Associazioni let nelle classi
Un'associazione let può apparire in un tipo di classe ma non in un tipo di struttura o di record. Per utilizzare un'associazione let in un tipo di classe, la classe deve disporre di un costruttore primario. I parametri del costruttore devono apparire dopo il nome del tipo nella definizione di classe. Un'associazione let in un tipo di classe definisce membri e campi privati per il tipo di classe e, insieme alle associazioni do nel tipo, forma il codice per il costruttore primario per il tipo. Negli esempi di codice seguenti viene illustrata una classe MyClass con campi field1 e field2 privati.
type MyClass(a) =
let field1 = a
let field2 = "text"
do printfn "%d %s" field1 field2
member this.F input =
printfn "Field1 %d Field2 %s Input %A" field1 field2 input
Gli ambiti di field1 e field2 sono limitati al tipo nel quale vengono dichiarati. Per ulteriori informazioni, vedere Associazioni let nelle classi (F#).
Parametri di tipo nelle associazioni let
Un'associazione let a livello di modulo in un tipo o in un'espressione di calcolo può presentare parametri di tipo espliciti. Un'associazione let in un'espressione, ad esempio all'interno di una definizione di funzione, non può avere parametri di tipo. Per ulteriori informazioni, vedere Generics (F#).
Attributi nelle associazioni let
Gli attributi possono essere applicati alle associazioni let di primo livello in un modulo, come mostrato nel codice seguente.
[<Obsolete>]
let function1 x y = x + y