Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese
Questa documentazione è stata archiviata e non viene gestita.

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

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


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)


Per ulteriori informazioni, vedere Funzioni (F#).

È 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#).

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#) e Classi (F#).

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#).

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


L'ambito di un'entità dichiarata con let l'associazione è limitato alla parte dell'ambito contenitore (ad esempio una funzione, un modulo, un file o una classe) dopo l'associazione viene visualizzato. Di conseguenza, può essere indicato che un'associazione let in viene introdotto un nome in un ambito. In un modulo, un valore o una funzione lasciare-associato è accessibile ai client di un form se il modulo è accessibile, poiché associazioni let in un modulo vengono compilati nelle funzioni pubbliche di modulo. Al contrario, associazioni let nella classe sono privato alla classe.

In genere, le funzioni in moduli devono essere deve essere qualificato con il nome del modulo una volta utilizzate dal codice client. Ad esempio, se un modulo Module1 dispone di una funzione function1, gli utenti specificherebbero Module1.function1 per fare riferimento alla funzione.

Gli utenti di un modulo possono contenere una dichiarazione di importazione per eseguire le funzioni nel modulo disponibile per l'utilizzo senza essere qualificata dal nome del modulo. Nell'esempio indicato in precedenza, gli utenti del modulo possono in tal caso aprono il modulo con la dichiarazione di importazione Module1 aperto e successivamente si riferiscono a function1 direttamente.

module Module1 =
    let function1 x = x + 1.0

module Module2 =
    let function2 x =
        Module1.function1 x

    open Module1
    let function3 x =
        function1 x

Alcuni moduli con l'attributo RequireQualifiedAccess, ovvero le funzioni che espongono devono essere deve essere qualificato con il nome del modulo. Ad esempio, il modulo di F# ha questo attributo.

Per ulteriori informazioni sui moduli e del controllo di accesso, vedere Moduli (F#) e Controllo di accesso (F#).

Mostra: