Valori letterali

Questo articolo fornisce una tabella che illustra come specificare il tipo di un valore letterale in F#.

Tipi letterali

La tabella seguente illustra i tipi letterali in F#. I caratteri che rappresentano cifre nella notazione esadecimale non fanno distinzione tra maiuscole e minuscole; i caratteri che identificano il tipo fanno distinzione tra maiuscole e minuscole.

Letterali nominati

I valori destinati a essere costanti possono essere contrassegnati con l'attributo letterale.

Questo attributo ha l'effetto di causare la compilazione di un valore come costante. Nell'esempio seguente, sia x che y seguenti sono valori non modificabili, ma x viene valutato in fase di esecuzione, mentre y è una costante in fase di compilazione.

let x = "a" + "b" // evaluated at run-time

[<Literal>]
let y = "a" + "b" // evaluated at compile-time

Perché le funzioni non possono calcolare valori letterali

L'attributo [<Literal>] richiede che i valori siano noti in fase di compilazione. Le funzioni, anche se sembrano produrre output costanti, vengono valutate in fase di esecuzione, rendendole non adatte per [<Literal>]. Questa restrizione garantisce che i valori letterali possano essere usati in modo sicuro in scenari come il matching dei pattern, i parametri degli attributi e l'interop con funzioni esterne.

Ad esempio, il tentativo di assegnare il risultato di una funzione a un valore letterale avrà esito negativo:

[<Literal>]
let yFunc() = "a" + "b" // error FS0267: this is not a valid constant expression

Questa distinzione è importante anche quando si chiama una funzione esterna . Ad esempio, DllImport è un attributo che deve conoscere il valore di myDLL durante la compilazione. Senza la dichiarazione di [<Literal>], il codice non verrà compilato:

[<Literal>]
let myDLL = "foo.dll"

[<DllImport(myDLL, CallingConvention = CallingConvention.Cdecl)>]
extern void HelloWorld()

Nelle espressioni di corrispondenza dei criteri di ricerca gli identificatori che iniziano con caratteri minuscoli vengono sempre considerati variabili da associare, anziché come valori letterali, pertanto è consigliabile usare in genere maiuscole iniziali quando si definiscono valori letterali.

[<Literal>]
let SomeJson = """{"numbers":[1,2,3,4,5]}"""

[<Literal>]
let Literal1 = "a" + "b"

[<Literal>]
let FileLocation =   __SOURCE_DIRECTORY__ + "/" + __SOURCE_FILE__

[<Literal>]
let Literal2 = 1 ||| 64

[<Literal>]
let Literal3 = System.IO.FileAccess.Read ||| System.IO.FileAccess.Write

Esempio di criteri di ricerca concisi usando valori letterali denominati

I valori letterali denominati possono rendere il pattern matching più conciso evitando la necessità di clausole when o logica aggiuntiva. Per esempio:

[<Literal>]
let ErrorCode = 404

let handleResponse code =
    match code with
    | ErrorCode -> "Not Found"
    | _ -> "Other Response"

Osservazioni

I valori letterali denominati sono utili per:

• Riscontro dei pattern senza una clausola when.
• Argomenti degli attributi.
• Argomenti del provider di tipi statici.

Le stringhe Unicode possono contenere codifiche esplicite che è possibile specificare usando \u seguito da un codice esadecimale a 16 bit (0000 - FFFF) o codifiche UTF-32 che è possibile specificare usando \U seguito da un codice esadecimale a 32 bit che rappresenta qualsiasi punto di codice Unicode (000000000 - 0010FFFF).

L'uso di operatori bit per bit diversi da ||| non è consentito.

Numeri interi in altre basi

I numeri interi con segno a 32 bit possono essere specificati in esadecimale, ottale o binario usando rispettivamente un prefisso 0x, 0o o 0b.

let numbers = (0x9F, 0o77, 0b1010)
// Result: numbers : int * int * int = (159, 63, 10)

Caratteri di sottolineatura nei valori letterali numerici

È possibile separare le cifre con il carattere di sottolineatura (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Valori di infinito a virgola mobile speciali

Sia i tipi numerici float che single a virgola mobile hanno associato valori speciali che rappresentano un infinito positivo e negativo.

Questi valori possono essere utilizzati direttamente o vengono restituiti quando si divide per zero a virgola mobile o un numero troppo piccolo per essere rappresentato dal tipo specificato. Per esempio:

> 1.0/0.0;;
val it: float = infinity

> 1.0/(-0.0);;
val it: float = -infinity

> 1.0/0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
;;
val it: float = infinity