Literais

Artigo
02/03/2025

Este artigo fornece uma tabela que mostra como especificar o tipo de literal em F#.

Tipos literais

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

Tipo	Descrição	Sufixo ou prefixo	Exemplos
sbyte	inteiro de 8 bits assinado	y	`86y` `0b00000101y`
byte	número natural de 8 bits sem sinal	uy	`86uy` `0b00000101uy`
int16	Inteiro de 16 bits assinado	s	`86s`
uint16	número natural de 16 bits não assinado	nos	`86us`
int int32	Inteiro de 32 bits assinado	l ou nenhum	`86` `86l`
uint uint32	número natural de 32 bits não assinado	u ou ul	`86u` `86ul`
nativeint	ponteiro nativo para um número natural assinado	n	`123n`
unativeint	ponteiro nativo como um número natural não assinado	un	`0x00002D3Fun`
int64	Inteiro de 64 bits assinado	L	`86L`
uint64	número natural de 64 bits não assinado	UL	`86UL`
single, float32	Número de ponto flutuante de 32 bits	F ou f	`4.14F` ou `4.14f` ou `infinityf` ou `-infinityf`
		Se	`0x00000000lf`
float; double	Número de ponto flutuante de 64 bits	nenhum	`4.14` ou `2.3E+32` ou `2.3e+32` ou `infinity` ou `-infinity`
		LF	`0x0000000000000000LF`
BIGINT	inteiro não limitado à representação de 64 bits	I	`9999999999999999999999999999I`
decimal	número fracionário representado como um ponto fixo ou número racional	M ou m	`0.7833M` ou `0.7833m`
Char	Caractere Unicode	nenhum	`'a'` ou `'\u0061'`
String	Cadeia de caracteres Unicode	nenhum	`"text\n"` or `@"c:\filename"` or `"""<book title="Paradise Lost">"""` or `"string1" + "string2"` Consulte também Cadeias de Caracteres.
byte	Caractere ASCII	B	`'a'B`
byte[]	Cadeia de caracteres ASCII	B	`"text"B`
Cadeia de caracteres ou bytes[]	cadeia de caracteres verbatim	prefixo @	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

Literais nomeados

Os valores destinados a serem 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 a seguir, x e y abaixo são valores imutáveis, mas x é avaliado em tempo de execução, enquanto y é uma constante de tempo de compilação.

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

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

Nota

As funções não podem ser usadas para calcular valores [<Literal>] porque os literais devem ser determinados em tempo de compilação e não podem depender da avaliação do runtime.

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 runtime, tornando-as inadequadas para [<Literal>]. Essa restrição garante que 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

Essa distinção também importa ao chamar 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>], esse código falharia ao 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 associadas, e não como 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

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"

Observações

Literais nomeados são úteis para:

Correspondência de padrões sem uma cláusula when.
Argumentos de atributo.
Argumentos de provedor de tipos estáticos.

Cadeias de caracteres Unicode podem conter codificações explícitas que você pode especificar usando \u seguidas por um código hexadecimal de 16 bits (0000 – FFFF) ou enco 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 diferente 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 de sublinhado (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Valores especiais de infinito em ponto flutuante

Os tipos numéricos de ponto flutuante float e single têm valores especiais associados que representam infinito positivo e negativo.

Valor F#	Tipo F#	Valor do .NET correspondente
`infinity` ou `+infinity`	`float`	PositiveInfinity
`-infinity`	`float`	NegativeInfinity
`infinityf` ou `+infinityf`	`single`	PositiveInfinity
`-infinityf`	`single`	NegativeInfinity

Esses valores podem ser usados diretamente ou são retornados ao serem divididos por um ponto flutuante zero ou um número muito pequeno para serem representados pelo tipo especificado. 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

Compartilhar via