Literais

Artigo
05/29/2024

Este artigo fornece uma tabela que mostra como especificar 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.

Tipo	Description	Sufixo ou prefixo	Exemplos
Sbyte	inteiro de 8 bits assinado	S	`86y` `0b00000101y`
byte	Número natural de 8 bits não assinado	uy	`86uy` `0b00000101uy`
int16	inteiro de 16 bits assinado	s	`86s`
UINT16	número natural de 16 bits não assinado	us	`86us`
número inteiro 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`
único, flutuante32	Número de ponto flutuante de 32 bits	F ou f	`4.14F`ou `4.14f` ou `infinityf-infinityf`
		LF	`0x00000000lf`
flutuar; duplo	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"` ou `@"c:\filename"` ou `"""<book title="Paradise Lost">"""` ou `"string1" + "string2"` Consulte também Strings.
byte	Caráter ASCII	N	`'a'B`
byte[]	String ASCII	N	`"text"B`
String ou byte[]	string literal	@ prefixo	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

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 a seguir, ambos e y abaixo x são valores imutáveis, mas x são avaliados 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

Por exemplo, essa distinção é importante ao chamar uma função externa, porque DllImport é um atributo que precisa saber o valor de myDLL durante a compilação. Sem a [<Literal>] declaração, 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

Observações

Os literais nomeados são úteis para:

Correspondência de padrões sem uma when cláusula.
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 seguidas 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 bitwise 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 0xou 0o0b prefixo, 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 de ponto flutuante

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

Valor F#	Tipo F#	Valor .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 dividir por um zero de vírgula 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

Partilhar via