リテラル

この記事では、F# でリテラルの型を指定する方法を示す表を示します。

リテラル型

F# のリテラル型を次の表に示します。 16 進表記で桁を表す文字は、大文字と小文字を区別しません。型を識別する文字は、大文字と小文字を区別します。

種類	説明	サフィックスまたはプレフィックス	使用例
sbyte	符号付き 8 ビット整数	y	86y 0b00000101y
バイト	符号なし 8 ビット自然数	uy	86uy 0b00000101uy
int16	符号付き 16 ビット整数	s	86s
uint16	符号なし 16 ビット自然数	私達	86us
int int32	符号付き 32 ビット整数	l または なし	86 86l
uint uint32	符号なし 32 ビット自然数	u または ul	86u 86ul
nativeint	符号付き自然数へのネイティブ ポインター	n	123n
unativeint	符号なし自然数値としてのネイティブ ポインター	un	0x00002D3Fun
int64	符号付き 64 ビット整数	L	86L
uint64	符号なし 64 ビット自然数	UL	86UL
single、float32	32 ビット浮動小数点数	F または f	4.14F、4.14f、infinityf、または -infinityf
		lf	0x00000000lf
float、double	64 ビット浮動小数点数	何一つ	4.14、2.3E+32、2.3e+32、infinity、または -infinity
		LF	0x0000000000000000LF
bigint	64 ビット表現に限定されない整数	I	9999999999999999999999999999I
decimal	分数は固定小数点または有理数として表される	M または m	0.7833M または 0.7833m
Char	Unicode 文字コード	何一つ	'a' または '\u0061'
糸	Unicode 文字列	何一つ	"text\n" または @"c:\filename" または """<book title="Paradise Lost">""" または "string1" + "string2" 「文字列」も参照してください。
バイト	ASCII 文字	B	'a'B
byte[]	ASCII 文字列	B	"text"B
String または byte[]	逐語的文字列	@ プレフィックス	@"\\server\share" (Unicode) @"\\server\share"B (ASCII)

名前付きリテラル

定数を対象とした値は、Literal 属性でマークできます。

この属性は、値を定数としてコンパイルする効果があります。 次の例では、以下の x と y の両方が不変の値ですが、x は実行時に評価されますが、y はコンパイル時の定数です。

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

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

手記

リテラルはコンパイル時に決定する必要があり、実行時の評価に依存できないため、関数を使用して [<Literal>] 値を計算することはできません。

関数がリテラルを計算できない理由

[<Literal>] 属性では、コンパイル時に値を認識する必要があります。 関数は、一定の出力を生成するように見えても、実行時に評価され、[<Literal>]には適さない。 この制限により、パターン マッチング、属性引数、外部関数との相互運用などのシナリオでリテラルを安全に使用できるようになります。

たとえば、関数の結果をリテラルに割り当てようとすると失敗します。

[<Literal>]
let yFunc() = "a" + "b" // error FS0267: this is not a valid constant expression

この区別は、外部関数を呼び出すときにも重要です。 たとえば、DllImport は、コンパイル時に myDLL の値を把握する必要がある属性です。 [<Literal>] 宣言がないと、このコードはコンパイルに失敗します。

[<Literal>]
let myDLL = "foo.dll"

[<DllImport(myDLL, CallingConvention = CallingConvention.Cdecl)>]
extern void HelloWorld()

パターン マッチング式では、小文字で始まる識別子は常に、リテラルとしてではなくバインドされる変数として扱われるので、通常、リテラルを定義するときは最初の大文字を使用する必要があります。

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

名前付きリテラルを使用した簡潔なパターン マッチングの例

名前付きリテラルを使用すると、when 句や追加のロジックが不要になるので、パターン マッチングをより簡潔にすることができます。 例えば：

[<Literal>]
let ErrorCode = 404

let handleResponse code =
    match code with
    | ErrorCode -> "Not Found"
    | _ -> "Other Response"

Remarks

名前付きリテラルは、次の場合に役立ちます。

• when 句のないパターン マッチング。
• 属性引数。
• 静的型プロバイダーの引数。

Unicode 文字列には、\u に続けて 16 ビットの 16 進数コード (0000 - FFFF)、または UTF-32 エンコードを使用して指定できる明示的なエンコードを含めることができます。このエンコードは、\U の後に任意の Unicode コード ポイント (00000000 - 00010FFFF) を表す 32 ビットの 16 進数コードを使用して指定できます。

||| 以外のビット演算子は使用できません。

その他のベースの整数

符号付き 32 ビット整数は、それぞれ 0x、0o、または 0b プレフィックスを使用して、16 進数、8 進数、またはバイナリで指定することもできます。

let numbers = (0x9F, 0o77, 0b1010)
// Result: numbers : int * int * int = (159, 63, 10)

数値リテラルの下線

数字はアンダースコア (_) で区切ることができます。

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

特殊な浮動小数点の無限大値

float と single 浮動小数点の両方の数値型には、正と負の無限大を表す特殊な値が関連付けられています。

F# 値	F# 型	対応する .NET 値
infinity または +infinity	float	PositiveInfinity
-infinity	float	NegativeInfinity
infinityf または +infinityf	single	PositiveInfinity
-infinityf	single	NegativeInfinity

これらの値は、直接使用することもできますし、浮動小数点の 0 または指定された型で表現できないほど小さい数値で除算する場合に返されることもあります。 例えば：

> 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