Literais

Este artigo apresenta uma tabela que explica como definir o tipo de um literal em F#.

Tipos literais

A tabela a seguir mostra os tipos literais em F#. Os caracteres que representam dígitos em notação hexadecimal não diferenciam maiúsculas de minúsculas; Os caracteres que identificam o tipo diferenciam maiúsculas de minúsculas.

Literais nomeados

Os valores que se destinam a ser constantes podem ser marcados com o atributo Literal.

Esse atributo tem o efeito de fazer com que um valor seja compilado como uma constante. No exemplo seguinte, tanto x como y abaixo são valores imutáveis, mas x é avaliado em tempo de execução, enquanto y é uma constante em tempo de compilação.

let x = "a" + "b" // evaluated at runtime

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

Por que as funções não podem calcular literais

O atributo [<Literal>] requer que os valores sejam conhecidos em tempo de compilação. As funções, mesmo que pareçam produzir saídas constantes, são avaliadas em tempo de execução, tornando-as inadequadas para [<Literal>]. Essa restrição garante que os literais possam ser usados com segurança em cenários como correspondência de padrões, argumentos de atributos e interoperabilidade com funções externas.

Por exemplo, a tentativa de atribuir o resultado de uma função a um literal falhará:

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

Esta distinção também é importante quando se chama uma função externa. Por exemplo, DllImport é um atributo que precisa saber o valor de myDLL durante a compilação. Sem a declaração [<Literal>], este código não conseguiria compilar:

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

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

Em expressões de correspondência de padrões, os identificadores que começam com caracteres minúsculos são sempre tratados como variáveis a serem vinculadas, em vez de literais, portanto, você geralmente deve usar maiúsculas iniciais ao definir literais.

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

Exemplo de correspondência concisa de padrões usando literais nomeados

Os literais nomeados podem tornar a correspondência de padrões mais concisa, evitando a necessidade de cláusulas when ou lógica adicional. Por exemplo:

[<Literal>]
let ErrorCode = 404

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

Comentários

Os literais com nome são úteis para:

• Correspondência de padrões sem uma cláusula when.
• Argumentos de atributo.
• Argumentos de provedor de tipo estático.

As cadeias de caracteres Unicode podem conter codificações explícitas que você pode especificar usando \u seguido por um código hexadecimal de 16 bits (0000 - FFFF) ou codificações UTF-32 que você pode especificar usando \U seguido por um código hexadecimal de 32 bits que representa qualquer ponto de código Unicode (00000000 - 0010FFFF).

O uso de operadores bit a bit diferentes de ||| não é permitido.

Inteiros em outras bases

Inteiros de 32 bits assinados também podem ser especificados em hexadecimal, octal ou binário usando um prefixo 0x, 0o ou 0b, respectivamente.

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

Sublinhados em literais numéricos

Você pode separar dígitos com o caractere sublinhado (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Valores especiais de infinito de ponto flutuante

Tanto o float como single tipos numéricos de vírgula flutuante têm valores especiais associados que representam infinito positivo e negativo.

Esses valores podem ser usados diretamente ou são retornados ao dividir por um zero de ponto flutuante ou um número muito pequeno para ser representado pelo tipo dado. Por exemplo:

> 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