Literais

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.14Fou 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