Associazioni let

Articolo
03/05/2024

Un'associazione associa un identificatore a un valore o a una funzione. Usare la let parola chiave per associare un nome a un valore o a una funzione.

Sintassi

// Binding a value:
let identifier-or-pattern [: type] =expressionbody-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =expressionbody-expression

Osservazioni:

La let parola chiave viene usata nelle espressioni di associazione per definire valori o valori di funzione per uno o più nomi. La forma più semplice dell'espressione let associa un nome a un valore semplice, come indicato di seguito.

let i = 1

Se si separa l'espressione dall'identificatore usando 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é solo un nome, è possibile specificare un modello che contiene nomi, ad esempio una tupla, come illustrato nel codice seguente.

let i, j, k = (1, 2, 3)

Body-expression è l'espressione in cui vengono usati i nomi. L'espressione del corpo viene visualizzata sulla propria riga, rientrata per allinearsi esattamente con il primo carattere nella let parola chiave :

let result =

    let i, j, k = (1, 2, 3)

    // Body expression:
    i + 2 * j + 3 * k

Un'associazione let può essere visualizzata a livello di modulo, nella definizione di un tipo di classe o in ambiti locali, ad esempio in una definizione di funzione. Un'associazione let al livello superiore di un modulo o in un tipo di classe non deve avere un'espressione del corpo, ma a altri livelli di ambito, è necessaria l'espressione del corpo. I nomi associati sono utilizzabili dopo il punto di definizione, ma non in alcun punto prima della visualizzazione 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 funzione seguono le regole per le associazioni di valori, ad eccezione del fatto che le associazioni di funzione includono il nome della funzione e i parametri, come illustrato nel codice seguente.

let function1 a = a + 1

In generale, i parametri sono modelli, ad esempio un modello di tupla:

let function2 (a, b) = a + b

Un'espressione let di associazione 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 altre informazioni, vedere Funzioni.

Annotazioni dei tipi

È possibile specificare i tipi per i parametri includendo due punti (:) seguito da un nome di tipo, tutti racchiusi 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 completo per function1, con numeri interi come tipi di parametro, sono le seguenti.

let function1 (a: int) : int = a + 1

Quando non sono presenti parametri di tipo espliciti, viene usata l'inferenza del tipo per determinare i tipi di parametri delle funzioni. Ciò può includere la generalizzazione automatica del tipo di un parametro da generico.

Per altre informazioni, vedere Generalizzazione automatica e Inferenza dei tipi.

Associazioni let nelle classi

Un'associazione let può essere visualizzata in un tipo di classe, ma non in una struttura o in un tipo di record. Per usare un'associazione let in un tipo di classe, la classe deve avere un costruttore primario. I parametri del costruttore devono essere visualizzati dopo il nome del tipo nella definizione della classe. Un'associazione let in un tipo di classe definisce campi privati e membri per tale tipo di classe e, insieme alle do associazioni nel tipo, forma il codice per il costruttore primario per il tipo. Negli esempi di codice seguenti viene mostrata una classe MyClass con campi field1 privati e field2.

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 in cui sono dichiarati. Per altre informazioni, vedere let Binding in Classi e classi.

Parametri di tipo in let Bindings

Un'associazione let a livello di modulo, in un tipo o in un'espressione di calcolo può avere 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 altre informazioni, vedere Generics.

Attributi per i binding let

Gli attributi possono essere applicati alle associazioni di primo livello let in un modulo, come illustrato nel codice seguente.

[<Obsolete>]
let function1 x y = x + y

Ambito e accessibilità delle associazioni let

L'ambito di un'entità dichiarata con un'associazione let è limitato alla parte dell'ambito contenitore (ad esempio una funzione, un modulo, un file o una classe) dopo la visualizzazione dell'associazione. Pertanto, si può dire che un'associazione let introduce un nome in un ambito. In un modulo, un valore o una funzione con associazione let è accessibile ai client di un modulo, purché il modulo sia accessibile, poiché le associazioni let in un modulo vengono compilate in funzioni pubbliche del modulo. Al contrario, le associazioni di tipo let in una classe sono private per la classe .

In genere, le funzioni nei moduli devono essere qualificate dal nome del modulo quando vengono usate dal codice client. Ad esempio, se un modulo Module1 ha una funzione function1, gli utenti specificano Module1.function1 di fare riferimento alla funzione .

Gli utenti di un modulo possono usare una dichiarazione di importazione per rendere disponibili le funzioni all'interno del modulo senza essere qualificate dal nome del modulo. Nell'esempio appena menzionato, gli utenti del modulo possono aprire il modulo usando la dichiarazione open Module1 di importazione e quindi fare riferimento direttamente a function1 .

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 hanno l'attributo RequireQualifiedAccess, il che significa che le funzioni esposte devono essere qualificate con il nome del modulo. Ad esempio, il modulo F# List ha questo attributo.

Per altre informazioni sui moduli e sul controllo di accesso, vedere Moduli e Controllo di accesso.