Literals

2 min to read Contributors
  • dendeli@microsoft.com
  • Maira Wenzel
  • Jared Hester
  • Phillip Carter
Note

The API reference links in this article will take you to MSDN. The docs.microsoft.com API reference is not complete.

This topic provides a table that shows how to specify the type of a literal in F#.

Literal Types

The following table shows the literal types in F#. Characters that represent digits in hexadecimal notation are not case-sensitive; characters that identify the type are case-sensitive.

Type Description Suffix or prefix Examples
sbyte signed 8-bit integer y 86y

0b00000101y
byte unsigned 8-bit natural number uy 86uy

0b00000101uy
int16 signed 16-bit integer s 86s
uint16 unsigned 16-bit natural number us 86us
int

int32
signed 32-bit integer l or none 86

86l
uint

uint32
unsigned 32-bit natural number u or ul 86u

86ul
unativeint native pointer as an unsigned natural number un 0x00002D3Fun
int64 signed 64-bit integer L 86L
uint64 unsigned 64-bit natural number UL 86UL
single, float32 32-bit floating point number F or f 4.14F or 4.14f
lf 0x00000000lf
float; double 64-bit floating point number none 4.14 or 2.3E+32 or 2.3e+32
LF 0x0000000000000000LF
bigint integer not limited to 64-bit representation I 9999999999999999999999999999I
decimal fractional number represented as a fixed point or rational number M or m 0.7833M or 0.7833m
Char Unicode character none 'a'
String Unicode string none "text\n"

or

@"c:\filename"

or

"""<book title="Paradise Lost">"""

or

"string1" + "string2"

See also Strings.
byte ASCII character B 'a'B
byte[] ASCII string B "text"B
String or byte[] verbatim string @ prefix @"\\server\share" (Unicode)

@"\\server\share"B (ASCII)

Remarks

Unicode strings can contain explicit encodings that you can specify by using \u followed by a 16-bit hexadecimal code or UTF-32 encodings that you can specify by using \U followed by a 32-bit hexadecimal code that represents a Unicode surrogate pair.

As of F# 3.1, you can use the + sign to combine string literals. You can also use the bitwise or (|||) operator to combine enum flags. For example, the following code is legal in F# 3.1:

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

The use of other bitwise operators isn't allowed.

Named Literals

Values that are intended to be constants can be marked with the Literal attribute. This attribute has the effect of causing a value to be compiled as a constant.

In pattern matching expressions, identifiers that begin with lowercase characters are always treated as variables to be bound, rather than as literals, so you should generally use initial capitals when you define literals.

See Also

Core.LiteralAttribute Class