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#. 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	a	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
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" ou @"c:\filename" ou """<book title="Paradise Lost">""" ou "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 byte[]	cadeia de caracteres verbatim	prefixo @	@"\\server\share" (Unicode) @"\\server\share"B (ASCII)

Literais nomeados

Valores destinados a serem constantes poderão ser marcados com o atributo Literal .

Este atributo compila um valor como uma constante. No exemplo a seguir, tanto x quanto 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

Por exemplo, essa distinção é importante ao chamar uma função externa, pois 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 vinculadas, em vez de literais, portanto, geralmente é necessário usar letras 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

Comentários

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.

As cadeias de caracteres Unicode podem conter codificações explícitas que podem ser especificadas usando \u seguidas por um código hexadecimal de 16 bits (0000 − FFFF) ou codificações UTF-32 que podem ser especificadas 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

É possível separar os 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 em ponto flutuante

Os tipos numéricos de ponto flutuante float e single têm valores especiais associados que representam o 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 ponto flutuante ou por um número muito pequeno para ser representado pelo tipo fornecido. 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