Letterlijke tekens

Dit artikel bevat een tabel die laat zien hoe u het type van een literal in F# kunt opgeven.

Letterlijke typen

In de volgende tabel ziet u de letterlijke typen in F#. Tekens die cijfers in hexadecimale notatie vertegenwoordigen, zijn niet hoofdlettergevoelig; tekens die het type identificeren, zijn hoofdlettergevoelig.

Benoemde letterlijke tekens

Waarden die zijn bedoeld om constanten te zijn, kunnen worden gemarkeerd met het kenmerk Letterlijke.

Dit kenmerk heeft het effect dat een waarde als een constante wordt gecompileerd. In het volgende voorbeeld zijn zowel x als y hieronder onveranderbare waarden, maar x wordt tijdens runtime geëvalueerd, terwijl y een compilatieconstante is.

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

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

Waarom functies geen letterlijke gegevens kunnen berekenen

Voor het kenmerk [<Literal>] moeten waarden tijdens het compileren bekend zijn. Functies, zelfs als ze constante uitvoer lijken te produceren, worden tijdens runtime geëvalueerd, waardoor ze ongeschikt zijn voor [<Literal>]. Deze beperking zorgt ervoor dat letterlijke waarden veilig kunnen worden gebruikt in scenario's zoals patroonkoppeling, kenmerkargumenten en interop met externe functies.

Als u bijvoorbeeld probeert het resultaat van een functie toe te wijzen aan een letterlijke waarde, zal dit mislukken.

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

Dit onderscheid is ook van belang bij het aanroepen van een externe functie. DllImport is bijvoorbeeld een kenmerk dat de waarde van myDLL tijdens de compilatie moet weten. Zonder de declaratie [<Literal>] kan deze code niet worden gecompileerd:

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

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

In patroonkoppelingsexpressies worden id's die beginnen met kleine letters altijd behandeld als variabelen die moeten worden gebonden, in plaats van als letterlijke waarden, dus moet u in het algemeen initiële hoofdletters gebruiken wanneer u letterlijke waarden definieert.

[<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

Voorbeeld van beknopt patroon dat overeenkomt met benoemde letterlijke waarden

Benoemde letterlijke waarden kunnen patroonmatching beknopter maken door de noodzaak voor when-clausules of aanvullende logica te vermijden. Bijvoorbeeld:

[<Literal>]
let ErrorCode = 404

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

Opmerkingen

Benoemde literals zijn handig voor:

• Patroonvergelijking zonder een when clausule.
• Kenmerkargumenten.
• Statische typeprovider-argumenten.

Unicode-tekenreeksen kunnen expliciete coderingen bevatten die u kunt opgeven met behulp van \u gevolgd door een 16-bits hexadecimale code (0000 - FFFF) of UTF-32-coderingen die u kunt opgeven met behulp van \U gevolgd door een 32-bits hexadecimale code die elk Unicode-codepunt vertegenwoordigt (000000000 - 0010FFFF).

Het gebruik van andere bitsgewijze operatoren dan ||| is niet toegestaan.

Gehele getallen in andere bases

Ondertekende 32-bits gehele getallen kunnen ook worden opgegeven in hexadecimaal, octaal of binair met respectievelijk een 0x, 0o of 0b voorvoegsel.

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

Onderstrepingstekens in numerieke literalen

U kunt cijfers scheiden met het onderstrepingsteken (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Speciale oneindige waarden voor zwevende komma

Zowel de float als de single drijvende-komma numerieke typen hebben speciale waarden die zijn gekoppeld aan positief en negatief oneindigheid.

Deze waarden kunnen rechtstreeks worden gebruikt of worden geretourneerd bij het delen door een drijvendekommageul of een getal dat te klein is om te worden weergegeven door het opgegeven type. Bijvoorbeeld:

> 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