模組 Stdlib

module Stdlib: sig .. end

OCaml 標準函式庫。

此模組會在每次編譯開始時自動開啟。因此，此模組的所有元件都可以使用其簡短名稱來參照，而無需在其前面加上 Stdlib 的前綴。

尤其是，它提供了內建類型（數字、布林值、位元組序列、字串、例外、參考、列表、陣列、輸入輸出通道等）以及標準函式庫模組的基本運算。

例外

val raise : exn -> 'a

引發給定的例外值

val raise_notrace : exn -> 'a

更快版本的 raise，不會記錄回溯。

自 4.02

val invalid_arg : string -> 'a

引發帶有給定字串的 Invalid_argument 例外。

val failwith : string -> 'a

引發帶有給定字串的 Failure 例外。

exception Exit

Exit 例外不會由任何函式庫函式引發。它提供給您的程式使用。

exception Match_failure of (string * int * int)

當模式匹配的任何情況都不適用時引發的例外。引數是來源程式碼中 match 關鍵字的位置（檔名、行號、欄號）。

exception Assert_failure of (string * int * int)

當斷言失敗時引發的例外。引數是來源程式碼中 assert 關鍵字的位置（檔名、行號、欄號）。

exception Invalid_argument of string

函式庫函式引發的例外，表示給定的引數沒有意義。此字串會給予程式設計師一些資訊。一般來說，不應捕獲此例外，它表示程式設計錯誤，應修改程式碼以避免觸發此例外。

exception Failure of string

函式庫函式引發的例外，表示它們在給定的引數上未定義。此字串旨在提供程式設計師一些資訊；您不得對字串文字進行模式匹配，因為它在未來版本中可能會更改（改用 Failure _）。

exception Not_found

當找不到所需物件時，搜尋函式引發的例外。

exception Out_of_memory

當記憶體不足以完成計算時，垃圾收集器引發的例外。（對於小堆積上的分配不可靠。）

exception Stack_overflow

當評估堆疊達到其最大大小時，位元組碼解譯器引發的例外。這通常表示使用者程式中存在無限或過深的遞迴。

在 4.10 之前，原生程式碼編譯器並未完全實作它。

exception Sys_error of string

輸入/輸出函式引發的例外，用於報告作業系統錯誤。此字串旨在提供程式設計師一些資訊；您不得對字串文字進行模式匹配，因為它在未來版本中可能會更改（改用 Sys_error _）。

exception End_of_file

輸入函式引發的例外，表示已到達檔案結尾。

exception Division_by_zero

當第二個引數為零時，整數除法和餘數運算引發的例外。

exception Sys_blocked_io

在非區塊 I/O 通道上無法進行 I/O 時引發的 Sys_error 特例。

exception Undefined_recursive_module of (string * int * int)

當評估基礎不良的遞迴模組定義時引發的例外。引數是來源程式碼中定義的位置（檔名、行號、欄號）。

比較

val (=) : 'a -> 'a -> bool

e1 = e2 測試 e1 和 e2 的結構相等性。可變結構（例如，參考和陣列）只有在它們的目前內容在結構上相等時才相等，即使兩個可變物件不是相同的實體物件。功能值之間的相等性會引發 Invalid_argument。循環資料結構之間的相等性可能不會終止。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (<>) : 'a -> 'a -> bool

(=) 的否定。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (<) : 'a -> 'a -> bool

請參閱 (>=)。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (>) : 'a -> 'a -> bool

請參閱 (>=)。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (<=) : 'a -> 'a -> bool

請參閱 (>=)。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (>=) : 'a -> 'a -> bool

結構排序函式。這些函式與整數、字元、字串、位元組序列和浮點數的通常排序一致，並將其擴展到所有類型的總排序。排序與 ( = ) 相容。與 ( = ) 的情況一樣，可變結構會依內容進行比較。功能值之間的比較會引發 Invalid_argument。循環結構之間的比較可能不會終止。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val compare : 'a -> 'a -> int

compare x y 如果 x 等於 y，則傳回 0；如果 x 小於 y，則傳回負整數；如果 x 大於 y，則傳回正整數。compare 實作的排序與上述定義的比較謂詞 =、< 和 > 相容，但浮點數值 nan 的處理方式有所不同。也就是說，比較謂詞將 nan 視為與任何其他浮點數值不同，包括它自己；而 compare 將 nan 視為等於它自己，並且小於任何其他浮點數值。對 nan 的這種處理方式可確保 compare 定義一個總排序關係。

應用於功能值的 compare 可能會引發 Invalid_argument。應用於循環結構的 compare 可能不會終止。

compare 函式可以用作 Set.Make 和 Map.Make 函子以及 List.sort 和 Array.sort 函式所需的比較函式。

val min : 'a -> 'a -> 'a

傳回兩個引數中較小的一個。如果其中一個引數包含浮點數值 nan，則結果未指定。

val max : 'a -> 'a -> 'a

傳回兩個引數中較大的一個。如果其中一個引數包含浮點數值 nan，則結果未指定。

val (==) : 'a -> 'a -> bool

e1 == e2 測試 e1 和 e2 的實體相等性。在可變類型（例如，參考、陣列、位元組序列、具有可變欄位的記錄和具有可變實例變數的物件）上，只有在 e1 的實體修改也會影響 e2 時，e1 == e2 才為 true。在不可變類型上，( == ) 的行為取決於實作；但是，保證 e1 == e2 表示 compare e1 e2 = 0。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (!=) : 'a -> 'a -> bool

(==) 的否定。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

布林運算

val not : bool -> bool

布林否定。

val (&&) : bool -> bool -> bool

布林「and」。評估是循序的，從左到右：在 e1 && e2 中，首先評估 e1，如果它傳回 false，則根本不會評估 e2。右結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (||) : bool -> bool -> bool

布林「or」。評估是循序的，從左到右：在 e1 || e2 中，首先評估 e1，如果它傳回 true，則根本不會評估 e2。右結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

除錯

val __LOC__ : string

__LOC__ 傳回此運算式在編譯器目前正在剖析的檔案中出現的位置，並採用 OCaml 的標準錯誤格式：「File %S, line %d, characters %d-%d」。

自 4.02

val __FILE__ : string

__FILE__ 傳回編譯器目前正在剖析的檔案的名稱。

自 4.02

val __LINE__ : int

__LINE__ 傳回此運算式在編譯器目前正在剖析的檔案中出現的行號。

自 4.02

val __MODULE__ : string

__MODULE__ 傳回編譯器目前正在剖析的檔案的模組名稱。

自 4.02

val __POS__ : string * int * int * int

__POS__ 傳回一個 tuple (file,lnum,cnum,enum)，對應於此運算式在編譯器目前正在剖析的檔案中出現的位置。file 是目前的檔名，lnum 是行號，cnum 是行中的字元位置，而 enum 是行中的最後一個字元位置。

自 4.02

val __FUNCTION__ : string

__FUNCTION__ 傳回目前函式或方法的名稱，包括任何封閉的模組或類別。

自 4.12

val __LOC_OF__ : 'a -> string * 'a

__LOC_OF__ expr 傳回一個 pair (loc, expr)，其中 loc 是 expr 在編譯器目前正在剖析的檔案中出現的位置，並採用 OCaml 的標準錯誤格式：「File %S, line %d, characters %d-%d」。

自 4.02

val __LINE_OF__ : 'a -> int * 'a

__LINE_OF__ expr 傳回一個 pair (line, expr)，其中 line 是運算式 expr 在編譯器目前正在剖析的檔案中出現的行號。

自 4.02

val __POS_OF__ : 'a -> (string * int * int * int) * 'a

__POS_OF__ expr 傳回一個 pair (loc,expr)，其中 loc 是一個 tuple (file,lnum,cnum,enum)，對應於運算式 expr 在編譯器目前正在剖析的檔案中出現的位置。file 是目前的檔名，lnum 是行號，cnum 是行中的字元位置，而 enum 是行中的最後一個字元位置。

自 4.02

組合運算子

val (|>) : 'a -> ('a -> 'b) -> 'b

反向應用運算子：x |> f |> g 完全等同於 g (f (x))。左結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

自 4.01

val (@@) : ('a -> 'b) -> 'a -> 'b

應用運算子：g @@ f @@ x 完全等同於 g (f (x))。右結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

自 4.01

整數算術

整數為 Sys.int_size 位元寬。所有運算都以 2^Sys.int_size 為模數進行。它們不會因溢位而失敗。

val (~-) : int -> int

一元否定。您也可以寫 - e 來代替 ~- e。一元運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (~+) : int -> int

一元加法。您也可以寫 + e 來代替 ~+ e。一元運算子，詳情請參閱 Ocaml_operators。

自 3.12

val succ : int -> int

succ x 等同於 x + 1。

val pred : int -> int

pred x 等同於 x - 1。

val (+) : int -> int -> int

整數加法。左結合運算子，詳情請參閱 Ocaml_operators。

val (-) : int -> int -> int

整數減法。左結合運算子，詳情請參閱 Ocaml_operators。

val ( * ) : int -> int -> int

整數乘法。左結合運算子，詳情請參閱 Ocaml_operators。

val (/) : int -> int -> int

整數除法。整數除法將其參數的實際商數向零捨入。更精確地說，如果 x >= 0 且 y > 0，則 x / y 是小於或等於 x 除以 y 的實際商數的最大整數。此外，(- x) / y = x / (- y) = - (x / y)。左結合運算子，詳情請參閱 Ocaml_operators。

如果第二個參數為 0，則引發 Division_by_zero 錯誤。

val (mod) : int -> int -> int

整數餘數。如果 y 不為零，則 x mod y 的結果滿足以下屬性：x = (x / y) * y + x mod y 且 abs(x mod y) <= abs(y) - 1。如果 y = 0，則 x mod y 引發 Division_by_zero 錯誤。請注意，只有在 x < 0 時，x mod y 才為負數。左結合運算子，詳情請參閱 Ocaml_operators。

如果 y 為零，則引發 Division_by_zero 錯誤。

val abs : int -> int

abs x 是 x 的絕對值。在 min_int 上，它本身就是 min_int，因此仍然為負數。

val max_int : int

可表示的最大整數。

val min_int : int

可表示的最小整數。

位元運算

val (land) : int -> int -> int

位元邏輯 AND。左結合運算子，詳情請參閱 Ocaml_operators。

val (lor) : int -> int -> int

位元邏輯 OR。左結合運算子，詳情請參閱 Ocaml_operators。

val (lxor) : int -> int -> int

位元邏輯 XOR。左結合運算子，詳情請參閱 Ocaml_operators。

val lnot : int -> int

位元邏輯 NOT。

val (lsl) : int -> int -> int

n lsl m 將 n 向左位移 m 位。如果 m < 0 或 m > Sys.int_size，則結果未定義。右結合運算子，詳情請參閱 Ocaml_operators。

val (lsr) : int -> int -> int

n lsr m 將 n 向右位移 m 位。這是一個邏輯位移：無論 n 的符號如何，都會插入零。如果 m < 0 或 m > Sys.int_size，則結果未定義。右結合運算子，詳情請參閱 Ocaml_operators。

val (asr) : int -> int -> int

n asr m 將 n 向右位移 m 位。這是一個算術位移：會複製 n 的符號位。如果 m < 0 或 m > Sys.int_size，則結果未定義。右結合運算子，詳情請參閱 Ocaml_operators。

浮點數算術

OCaml 的浮點數遵循 IEEE 754 標準，使用雙精度（64 位元）數字。浮點數運算永遠不會在溢位、下溢、除以零等情況下引發例外。相反，會視情況傳回特殊的 IEEE 數字，例如 infinity 表示 1.0 /. 0.0、neg_infinity 表示 -1.0 /. 0.0，以及 nan (「非數字」) 表示 0.0 /. 0.0。這些特殊數字會如預期般在浮點數計算中傳播：例如，1.0 /. infinity 為 0.0，以 nan 作為引數的基本算術運算 (+.、-.、*.、/.) 會傳回 nan，等等。

val (~-.) : float -> float

一元負號。您也可以寫 -. e 來代替 ~-. e。一元運算子，詳情請參閱 Ocaml_operators。

val (~+.) : float -> float

一元加法。您也可以寫 +. e 來代替 ~+. e。一元運算子，詳情請參閱 Ocaml_operators。

自 3.12

val (+.) : float -> float -> float

浮點數加法。左結合運算子，詳情請參閱 Ocaml_operators。

val (-.) : float -> float -> float

浮點數減法。左結合運算子，詳情請參閱 Ocaml_operators。

val ( *. ) : float -> float -> float

浮點數乘法。左結合運算子，詳情請參閱 Ocaml_operators。

val (/.) : float -> float -> float

浮點數除法。左結合運算子，詳情請參閱 Ocaml_operators。

val ( ** ) : float -> float -> float

指數運算。右結合運算子，詳情請參閱 Ocaml_operators。

val sqrt : float -> float

平方根。

val exp : float -> float

指數。

val log : float -> float

自然對數。

val log10 : float -> float

以 10 為底的對數。

val expm1 : float -> float

expm1 x 計算 exp x -. 1.0，即使 x 接近 0.0，也能提供數值精確的結果。

自 3.12

val log1p : float -> float

log1p x 計算 log(1.0 +. x)（自然對數），即使 x 接近 0.0，也能提供數值精確的結果。

自 3.12

val cos : float -> float

餘弦。引數以弧度表示。

val sin : float -> float

正弦。引數以弧度表示。

val tan : float -> float

正切。引數以弧度表示。

val acos : float -> float

反餘弦。引數必須在 [-1.0, 1.0] 範圍內。結果以弧度表示，介於 0.0 和 pi 之間。

val asin : float -> float

反正弦。引數必須在 [-1.0, 1.0] 範圍內。結果以弧度表示，介於 -pi/2 和 pi/2 之間。

val atan : float -> float

反正切。結果以弧度表示，介於 -pi/2 和 pi/2 之間。

val atan2 : float -> float -> float

atan2 y x 傳回 y /. x 的反正切。使用 x 和 y 的符號來判斷結果的象限。結果以弧度表示，介於 -pi 和 pi 之間。

val hypot : float -> float -> float

hypot x y 傳回 sqrt(x *. x + y *. y)，也就是邊長為 x 和 y 的直角三角形的斜邊長度，或等效地說，點 (x,y) 到原點的距離。如果 x 或 y 其中一個為無限大，則即使另一個為 nan，也會傳回 infinity。

自 4.00

val cosh : float -> float

雙曲餘弦。引數以弧度表示。

val sinh : float -> float

雙曲正弦。引數以弧度表示。

val tanh : float -> float

雙曲正切。引數以弧度表示。

val acosh : float -> float

雙曲反餘弦。引數必須在 [1.0, inf] 範圍內。結果以弧度表示，介於 0.0 和 inf 之間。

自 4.13

val asinh : float -> float

雙曲反正弦。引數和結果的範圍涵蓋整個實數軸。結果以弧度表示。

自 4.13

val atanh : float -> float

雙曲反正切。引數必須在 [-1.0, 1.0] 範圍內。結果以弧度表示，範圍涵蓋整個實數軸。

自 4.13

val ceil : float -> float

向上捨入為整數值。ceil f 傳回大於或等於 f 的最小整數值。結果會以浮點數傳回。

val floor : float -> float

向下捨入為整數值。floor f 傳回小於或等於 f 的最大整數值。結果會以浮點數傳回。

val abs_float : float -> float

abs_float f 傳回 f 的絕對值。

val copysign : float -> float -> float

copysign x y 傳回一個浮點數，其絕對值與 x 相同，而符號與 y 相同。如果 x 為 nan，則傳回 nan。如果 y 為 nan，則傳回 x 或 -. x，但未指定是哪一個。

自 4.00

val mod_float : float -> float -> float

mod_float a b 傳回 a 對於 b 的餘數。傳回的值為 a -. n *. b，其中 n 是 a /. b 向零捨入為整數的商數。

val frexp : float -> float * int

frexp f 傳回 f 的有效位數和指數的配對。當 f 為零時，f 的有效位數 x 和指數 n 等於零。當 f 不為零時，它們的定義為 f = x *. 2 ** n 且 0.5 <= x < 1.0。

val ldexp : float -> int -> float

ldexp x n 傳回 x *. 2 ** n。

val modf : float -> float * float

modf f 傳回 f 的小數部分和整數部分的配對。

val float : int -> float

與 float_of_int 相同。

val float_of_int : int -> float

將整數轉換為浮點數。

val truncate : float -> int

與 int_of_float 相同。

val int_of_float : float -> int

將給定的浮點數截斷為整數。如果引數為 nan 或超出可表示整數的範圍，則結果未指定。

val infinity : float

正無限大。

val neg_infinity : float

負無限大。

val nan : float

一個特殊的浮點數值，表示未定義運算的結果，例如 0.0 /. 0.0。代表「非數字」。除非在 IEEE 754 標準中另有規定，否則任何以 nan 作為引數的浮點數運算都會傳回 nan 作為結果。至於浮點數比較，如果其中一個或兩個引數為 nan，則 =、<、<=、> 和 >= 會傳回 false，而 <> 會傳回 true。

自 5.1 版以來，nan 是靜默 NaN；在此之前，它是訊號 NaN。

val max_float : float

float 類型最大的正有限值。

val min_float : float

float 類型最小的正非零非正規化值。

val epsilon_float : float

1.0 與大於 1.0 的最小可精確表示浮點數之間的差值。

type fpclass =

`\|`	`FP_normal`	`(*`	正規數，非以下任何一項	`*)`
`\|`	`FP_subnormal`	`(*`	非常接近 0.0 的數字，精確度降低	`*)`
`\|`	`FP_zero`	`(*`	數字為 0.0 或 -0.0	`*)`
`\|`	`FP_infinite`	`(*`	數字為正或負無限大	`*)`
`\|`	`FP_nan`	`(*`	非數字：未定義運算的結果	`*)`

由 classify_float 函式判斷的五種浮點數類別。

val classify_float : float -> fpclass

傳回給定浮點數的類別：正規、次正規、零、無限大或非數字。

字串運算

模組 String 中提供更多字串運算。

val (^) : string -> string -> string

字串串連。右結合運算子，詳情請參閱 Ocaml_operators。

如果結果長度超過 Sys.max_string_length 位元組，則引發 Invalid_argument 錯誤。

字元運算

模組 Char 中提供了更多字元操作。

val int_of_char : char -> int

傳回參數的 ASCII 碼。

val char_of_int : int -> char

傳回具有給定 ASCII 碼的字元。

若引數超出 0--255 範圍，則引發 Invalid_argument 錯誤。

Unit 運算

val ignore : 'a -> unit

捨棄其引數的值並傳回 ()。例如，ignore(f x) 會捨棄具有副作用的函數 f 的結果。它等同於 f x; ()，但後者可能會產生編譯器警告；改為寫入 ignore(f x) 可避免警告。

字串轉換函式

val string_of_bool : bool -> string

傳回布林值的字串表示形式。由於傳回的值可能會被共用，使用者不應直接修改它們。

val bool_of_string_opt : string -> bool option

將給定的字串轉換為布林值。

如果字串不是 "true" 或 "false"，則傳回 None。

自 4.05

val bool_of_string : string -> bool

與 bool_of_string_opt 相同，但會引發 Invalid_argument "bool_of_string" 錯誤，而不是傳回 None。

val string_of_int : int -> string

以十進位傳回整數的字串表示形式。

val int_of_string_opt : string -> int option

將給定的字串轉換為整數。字串會以十進位（預設，或如果字串以 0u 開頭）、十六進位（如果字串以 0x 或 0X 開頭）、八進位（如果字串以 0o 或 0O 開頭）或二進位（如果字串以 0b 或 0B 開頭）讀取。

0u 前綴將輸入讀取為範圍 [0, 2*max_int+1] 中的無符號整數。如果輸入超出 max_int，則會將其轉換為有符號整數 min_int + input - max_int - 1。

_ (底線) 字元可以出現在字串中的任何位置，並且會被忽略。

如果給定的字串不是整數的有效表示形式，或者如果表示的整數超出類型 int 中可表示的整數範圍，則傳回 None。

自 4.05

val int_of_string : string -> int

與 int_of_string_opt 相同，但會引發 Failure "int_of_string" 錯誤，而不是傳回 None。

val string_of_float : float -> string

傳回浮點數的字串表示形式。

此轉換可能會導致精確度損失。如需更精確地控制數字的列印方式，請參閱 Printf。

val float_of_string_opt : string -> float option

將給定的字串轉換為浮點數。字串會以十進位（預設）或十六進位（以 0x 或 0X 標記）讀取。

十進位浮點數的格式為 [-] dd.ddd (e|E) [+|-] dd ，其中 d 代表十進位數字。

十六進位浮點數的格式為 [-] 0(x|X) hh.hhh (p|P) [+|-] dd ，其中 h 代表十六進位數字，而 d 代表十進位數字。

在這兩種情況下，必須至少提供整數和小數部分之一；指數部分是選用的。

_ (底線) 字元可以出現在字串中的任何位置，並且會被忽略。

根據執行平台，可能會接受其他浮點數表示形式，但不應依賴這些形式。

如果給定的字串不是浮點數的有效表示形式，則傳回 None。

自 4.05

val float_of_string : string -> float

與 float_of_string_opt 相同，但會引發 Failure "float_of_string" 錯誤，而不是傳回 None。

Pair 運算

val fst : 'a * 'b -> 'a

傳回配對的第一個元件。

val snd : 'a * 'b -> 'b

傳回配對的第二個元件。

List 運算

模組 List 中提供了更多清單操作。

val (@) : 'a list -> 'a list -> 'a list

l0 @ l1 將 l1 附加到 l0。與 List.append 相同的函數。右結合運算子，如需更多資訊，請參閱 Ocaml_operators。

自 5.1 版起，此函數為尾部遞迴。

輸入/輸出

注意：當它們調用的系統呼叫失敗時，所有輸入/輸出函數都會引發 Sys_error 錯誤。

type in_channel

輸入通道的類型。

type out_channel

輸出通道的類型。

val stdin : in_channel

程序的標準輸入。

val stdout : out_channel

程序的標準輸出。

val stderr : out_channel

程序的標準錯誤輸出。

標準輸出上的輸出函式

val print_char : char -> unit

在標準輸出上列印一個字元。

val print_string : string -> unit

在標準輸出上列印一個字串。

val print_bytes : bytes -> unit

在標準輸出上列印一個位元組序列。

自 4.02

val print_int : int -> unit

在標準輸出上以十進位列印一個整數。

val print_float : float -> unit

在標準輸出上以十進位列印一個浮點數。

數字到字串的轉換使用 string_of_float，並且可能會導致精確度損失。

val print_endline : string -> unit

在標準輸出上列印一個字串，後跟一個換行字元，並刷新標準輸出。

val print_newline : unit -> unit

在標準輸出上列印一個換行字元，並刷新標準輸出。這可用於模擬標準輸出的行緩衝。

標準錯誤上的輸出函式

val prerr_char : char -> unit

在標準錯誤上列印一個字元。

val prerr_string : string -> unit

在標準錯誤上列印一個字串。

val prerr_bytes : bytes -> unit

在標準錯誤上列印一個位元組序列。

自 4.02

val prerr_int : int -> unit

在標準錯誤上以十進位列印一個整數。

val prerr_float : float -> unit

在標準錯誤上以十進位列印一個浮點數。

數字到字串的轉換使用 string_of_float，並且可能會導致精確度損失。

val prerr_endline : string -> unit

在標準錯誤上列印一個字串，後跟一個換行字元，並刷新標準錯誤。

val prerr_newline : unit -> unit

在標準錯誤上列印一個換行字元，並刷新標準錯誤。

標準輸入上的輸入函式

val read_line : unit -> string

刷新標準輸出，然後從標準輸入讀取字元，直到遇到換行字元。

傳回讀取的所有字元的字串，不包含結尾的換行字元。

如果在行首達到檔案結尾，則引發 End_of_file 錯誤。

val read_int_opt : unit -> int option

刷新標準輸出，然後從標準輸入讀取一行並將其轉換為整數。

如果讀取的行不是整數的有效表示形式，則傳回 None。

自 4.05

val read_int : unit -> int

與 read_int_opt 相同，但會引發 Failure "int_of_string" 錯誤，而不是傳回 None。

val read_float_opt : unit -> float option

刷新標準輸出，然後從標準輸入讀取一行並將其轉換為浮點數。

如果讀取的行不是浮點數的有效表示形式，則傳回 None。

自 4.05

val read_float : unit -> float

與 read_float_opt 相同，但會引發 Failure "float_of_string" 錯誤，而不是傳回 None。

一般輸出函式

type open_flag =

`\|`	`Open_rdonly`	`(*`	開啟以進行讀取。	`*)`
`\|`	`Open_wronly`	`(*`	開啟以進行寫入。	`*)`
`\|`	`Open_append`	`(*`	開啟以進行附加：始終寫入檔案結尾。	`*)`
`\|`	`Open_creat`	`(*`	如果檔案不存在，則建立檔案。	`*)`
`\|`	`Open_trunc`	`(*`	如果檔案已存在，則清空檔案。	`*)`
`\|`	`Open_excl`	`(*`	如果 Open_creat 且檔案已存在，則失敗。	`*)`
`\|`	`Open_binary`	`(*`	以二進位模式開啟（無轉換）。	`*)`
`\|`	`Open_text`	`(*`	以文字模式開啟（可能會執行轉換）。	`*)`
`\|`	`Open_nonblock`	`(*`	以非封鎖模式開啟。	`*)`

用於 open_out_gen 和 open_in_gen 的開啟模式。

val open_out : string -> out_channel

開啟指定的檔案以進行寫入，並傳回該檔案上新的輸出通道，位於檔案的開頭。如果檔案已存在，則會將其截斷為零長度。如果檔案不存在，則會建立檔案。

val open_out_bin : string -> out_channel

與 open_out 相同，但檔案以二進位模式開啟，因此在寫入期間不會發生轉換。在不區分文字模式和二進位模式的作業系統上，此函數的行為類似於 open_out。

val open_out_gen : open_flag list -> int -> string -> out_channel

open_out_gen mode perm filename 開啟指定的檔案以進行寫入，如上所述。額外的引數 mode 指定開啟模式。額外的引數 perm 指定檔案權限，以防必須建立檔案。open_out 和 open_out_bin 是此函數的特殊情況。

val flush : out_channel -> unit

刷新與給定輸出通道相關聯的緩衝區，執行該通道上所有擱置的寫入。互動式程式必須謹慎地在正確的時間刷新標準輸出和標準錯誤。

val flush_all : unit -> unit

刷新所有開啟的輸出通道；忽略錯誤。

val output_char : out_channel -> char -> unit

將字元寫入給定的輸出通道。

val output_string : out_channel -> string -> unit

將字串寫入給定的輸出通道。

val output_bytes : out_channel -> bytes -> unit

將位元組序列寫入給定的輸出通道。

自 4.02

val output : out_channel -> bytes -> int -> int -> unit

output oc buf pos len 將位元組序列 buf 中從偏移量 pos 開始的 len 個字元寫入給定的輸出通道 oc。

如果 pos 和 len 沒有指定 buf 的有效範圍，則引發 Invalid_argument 錯誤。

val output_substring : out_channel -> string -> int -> int -> unit

與 output 相同，但以字串作為引數，而不是位元組序列。

自 4.02

val output_byte : out_channel -> int -> unit

將一個 8 位元整數（作為具有該程式碼的單個字元）寫入給定的輸出通道。給定的整數以 256 為模。

val output_binary_int : out_channel -> int -> unit

將一個整數以二進位格式（4 個位元組，大端）寫入給定的輸出通道。給定的整數以 2³² 為模。讀回該整數的唯一可靠方法是透過 input_binary_int 函數。對於 OCaml 的特定版本，此格式在所有機器上都是相容的。

val output_value : out_channel -> 'a -> unit

將任何類型的結構化值表示形式寫入通道。會偵測並保留值內的循環和共用。物件可以透過 input_value 函數讀回。如需更多資訊，請參閱模組 Marshal 的說明。output_value 等同於具有空旗標清單的 Marshal.to_channel。

val seek_out : out_channel -> int -> unit

seek_out chan pos 將通道 chan 的目前寫入位置設定為 pos。這僅適用於一般檔案。對於其他類型的檔案（例如終端機、管道和通訊端），行為未指定。

val pos_out : out_channel -> int

傳回給定通道的目前寫入位置。不適用於以 Open_append 旗標開啟的通道（傳回未指定的結果）。對於在 Windows 下以文字模式開啟的檔案，傳回的位置是近似的（由於換行轉換）；特別是，使用 pos_out 儲存目前位置，然後使用 seek_out 返回此位置將無法正常運作。為了讓此程式設計慣用寫法能夠可靠且可移植地運作，必須以二進位模式開啟檔案。

val out_channel_length : out_channel -> int

傳回開啟給定通道的常規檔案的大小（字元數）。如果通道開啟在不是常規檔案的檔案上，則結果沒有意義。

val close_out : out_channel -> unit

關閉給定的通道，刷新所有緩衝的寫入操作。輸出函數在應用於已關閉的輸出通道時會引發 Sys_error 例外狀況，但 close_out 和 flush 除外，它們在應用於已關閉的通道時不會執行任何操作。請注意，如果作業系統在刷新或關閉時發出錯誤訊號，close_out 可能會引發 Sys_error 錯誤。

val close_out_noerr : out_channel -> unit

與 close_out 相同，但忽略所有錯誤。

val set_binary_mode_out : out_channel -> bool -> unit

set_binary_mode_out oc true 將通道 oc 設定為二進制模式：輸出期間不進行任何轉換。set_binary_mode_out oc false 將通道 oc 設定為文字模式：根據作業系統，輸出期間可能會進行某些轉換。例如，在 Windows 下，行尾符號將從 \n 轉換為 \r\n。此函數在不區分文字模式和二進制模式的作業系統下無效。

一般輸入函式

val open_in : string -> in_channel

開啟指定的檔案以進行讀取，並在該檔案上返回一個新的輸入通道，定位於檔案的開頭。

val open_in_bin : string -> in_channel

與 open_in 相同，但檔案以二進制模式開啟，因此讀取期間不會進行任何轉換。在不區分文字模式和二進制模式的作業系統上，此函數的行為類似於 open_in。

val open_in_gen : open_flag list -> int -> string -> in_channel

open_in_gen mode perm filename 開啟指定的檔案以進行讀取，如上所述。額外參數 mode 和 perm 指定開啟模式和檔案權限。open_in 和 open_in_bin 是此函數的特殊情況。

val input_char : in_channel -> char

從給定的輸入通道讀取一個字元。

引發 End_of_file 異常，如果沒有更多字元可讀取。

val input_line : in_channel -> string

從給定的輸入通道讀取字元，直到遇到換行符號。返回讀取的所有字元字串，不包含結尾的換行符號。

如果在行首達到檔案結尾，則引發 End_of_file 錯誤。

val input : in_channel -> bytes -> int -> int -> int

input ic buf pos len 從給定的通道 ic 讀取最多 len 個字元，將它們儲存在位元組序列 buf 中，從字元編號 pos 開始。它返回實際讀取的字元數，介於 0 和 len 之間（含）。傳回值 0 表示已到達檔案結尾。介於 0 和 len 之間的傳回值（不含）表示並非所有要求的 len 個字元都被讀取，原因可能是當時沒有更多字元可用，或實作認為執行部分讀取更方便；如果需要，必須再次呼叫 input 來讀取剩餘的字元。（另請參閱 really_input 以讀取確切的 len 個字元。）如果 pos 和 len 沒有指定 buf 的有效範圍，則會引發例外狀況 Invalid_argument "input"。

val really_input : in_channel -> bytes -> int -> int -> unit

really_input ic buf pos len 從通道 ic 讀取 len 個字元，將它們儲存在位元組序列 buf 中，從字元編號 pos 開始。

引發
- End_of_file 異常，如果在讀取 len 個字元之前到達檔案結尾。
- Invalid_argument 異常，如果 pos 和 len 沒有指定 buf 的有效範圍。

val really_input_string : in_channel -> int -> string

really_input_string ic len 從通道 ic 讀取 len 個字元，並將它們以新字串形式傳回。

自 4.02
引發 End_of_file 異常，如果在讀取 len 個字元之前到達檔案結尾。

val input_byte : in_channel -> int

與 input_char 相同，但返回代表字元的 8 位元整數。

引發 End_of_file 異常，如果到達檔案結尾。

val input_binary_int : in_channel -> int

從給定的輸入通道讀取以二進制格式（4 個位元組，大端序）編碼的整數。請參閱 output_binary_int。

引發 End_of_file 異常，如果在讀取整數時到達檔案結尾。

val input_value : in_channel -> 'a

讀取結構化值的表示形式，如 output_value 所產生，並返回對應的值。此函數與 Marshal.from_channel 相同；有關更多資訊，尤其是關於缺乏型別安全性的資訊，請參閱模組 Marshal 的說明。

val seek_in : in_channel -> int -> unit

seek_in chan pos 將通道 chan 的目前讀取位置設定為 pos。這僅適用於常規檔案。對於其他種類的檔案，其行為未指定。

val pos_in : in_channel -> int

傳回給定通道的目前讀取位置。對於在 Windows 下以文字模式開啟的檔案，傳回的位置是近似的（由於行尾符號轉換）；特別是，使用 pos_in 儲存目前位置，然後使用 seek_in 回到此位置將無法運作。為了使這種程式設計慣用語可靠且可移植地運作，檔案必須以二進制模式開啟。

val in_channel_length : in_channel -> int

傳回給定通道開啟的常規檔案的大小（字元數）。如果通道開啟的檔案不是常規檔案，則結果沒有意義。傳回的大小不考慮從以文字模式開啟的通道讀取時可能執行的行尾符號轉換。

val close_in : in_channel -> unit

關閉給定的通道。當輸入函數應用於已關閉的輸入通道時，會引發 Sys_error 例外狀況，但 close_in 除外，它在應用於已關閉的通道時不執行任何操作。

val close_in_noerr : in_channel -> unit

與 close_in 相同，但忽略所有錯誤。

val set_binary_mode_in : in_channel -> bool -> unit

set_binary_mode_in ic true 將通道 ic 設定為二進制模式：輸入期間不進行任何轉換。set_binary_mode_out ic false 將通道 ic 設定為文字模式：根據作業系統，輸入期間可能會進行某些轉換。例如，在 Windows 下，行尾符號將從 \r\n 轉換為 \n。此函數在不區分文字模式和二進制模式的作業系統下無效。

大型檔案的操作

module LargeFile: sig .. end

對大型檔案的操作。

參考

type 'a ref = {

mutable contents : 'a;

}

包含類型為 'a 的值的參考（可變間接儲存格）的類型。

val ref : 'a -> 'a ref

返回一個包含給定值的全新參考。

val (!) : 'a ref -> 'a

!r 返回參考 r 的目前內容。等效於 fun r -> r.contents。一元運算子，請參閱 Ocaml_operators 以取得更多資訊。

val (:=) : 'a ref -> 'a -> unit

r := a 將 a 的值儲存在參考 r 中。等效於 fun r v -> r.contents <- v。右結合運算子，請參閱 Ocaml_operators 以取得更多資訊。

val incr : int ref -> unit

遞增給定參考中包含的整數。等效於 fun r -> r := succ !r。

val decr : int ref -> unit

遞減給定參考中包含的整數。等效於 fun r -> r := pred !r。

結果類型

type ('a, 'b) result =

`\|`	`Ok of 'a`
`\|`	`Error of 'b`

自 4.03

格式化字串的操作

格式字串是具有特殊語彙慣例的字元字串，這些慣例定義了格式化輸入/輸出函數的功能。格式字串用於使用模組 Scanf 中的格式化輸入函數讀取資料，以及使用模組 Printf 和 Format 中的格式化輸出函數列印資料。

格式字串由三種實體組成

轉換規格，由特殊字元 '%' 開始，後接一個或多個字元，指定要讀取或列印的引數類型。
格式化指示，由特殊字元 '@' 開始，後接一個或多個字元，指定如何讀取或列印引數。
純文字字元，即具有一般語彙慣例的規則字元。純文字字元指定要在輸入中讀取或在輸出中列印的字串文字。

還有一個額外的語彙規則，用於跳脫格式字串中的特殊字元 '%' 和 '@'：如果特殊字元後面跟著 '%' 字元，則會將其視為純文字字元。換句話說，"%%" 被視為純文字 '%'，而 "%@" 被視為純文字 '@'。

有關可用的轉換規格和格式化指示的更多資訊，請閱讀模組 Scanf、Printf 和 Format 的說明文件。

格式字串具有通用且高度多型的類型 ('a, 'b, 'c, 'd, 'e, 'f) format6。下面包含兩個簡化類型 format 和 format4，以確保與早期版本的 OCaml 的向後相容性。

格式字串類型參數的含義如下

'a 是格式化輸出函數（printf 樣式的函數）的格式參數類型； 'a 是格式化輸入函數（scanf 樣式的函數）讀取的值的類型。

'b 是格式化輸入函數的輸入來源類型，以及格式化輸出函數的輸出目標類型。對於模組 Printf 中的 printf 樣式函數，'b 通常是 out_channel；對於模組 Format 中的 printf 樣式函數，'b 通常是 Format.formatter；對於模組 Scanf 中的 scanf 樣式函數，'b 通常是 Scanf.Scanning.in_channel。

類型引數 'b 也是給予使用者定義的列印函數以進行 %a 和 %t 轉換，以及給予使用者定義的讀取函數以進行 %r 轉換的第一個引數的類型。

'c 是 %a 和 %t 列印函數的結果類型，同時也是傳遞給 kprintf 樣式函數的第一個參數，或是傳遞給 kscanf 樣式函數的參數的類型。

'd 是 scanf 樣式函數的參數類型。

'e 是 scanf 樣式函數的接收器函數的類型。

'f 是一個格式化輸入/輸出函數調用的最終結果類型：對於 printf 樣式函數，它通常是 unit；對於 scanf 樣式函數，它通常是接收器函數的結果類型。

type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6

type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6

type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4

val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string

將格式字串轉換為字串。

val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
       ('a, 'b, 'c, 'd, 'e, 'f) format6

format_of_string s 返回從字串文字 s 讀取的格式字串。注意：format_of_string 無法轉換非文字的字串參數。如果需要此功能，請使用更通用的 Scanf.format_from_string 函數。

val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
       ('f, 'b, 'c, 'e, 'g, 'h) format6 ->
       ('a, 'b, 'c, 'd, 'g, 'h) format6

f1 ^^ f2 連接格式字串 f1 和 f2。結果是一個格式字串，其行為如同格式字串 f1 和 f2 的串聯：在格式化輸出時，它接受來自 f1 的參數，然後接受來自 f2 的參數；在格式化輸入時，它返回來自 f1 的結果，然後返回來自 f2 的結果。這是一個右結合運算符，請參閱 Ocaml_operators 以取得更多資訊。

程式終止

val exit : int -> 'a

終止進程，並將給定的狀態碼返回給作業系統：通常 0 表示沒有錯誤，而小的正整數表示失敗。所有打開的輸出通道都會使用 flush_all 清空。接著會調用使用 Domain.at_exit 註冊的回調函數，然後調用使用 at_exit 註冊的回調函數。

每次程式正常終止時，都會執行隱式的 exit 0。如果程式因為未捕獲的例外而提早終止，則會執行隱式的 exit 2。

val at_exit : (unit -> unit) -> unit

註冊給定的函數，以便在程式終止時呼叫。當程式執行以下任何操作時，將會呼叫使用 at_exit 註冊的函數：

執行 exit
終止，無論是正常終止還是由於未捕獲的例外而終止
執行 C 函數 caml_shutdown。這些函數會以「後進先出」的順序呼叫：最近使用 at_exit 添加的函數會最先被呼叫。

標準函式庫模組

module Arg: Arg

module Array: Array

module ArrayLabels: ArrayLabels

module Atomic: Atomic

module Bigarray: Bigarray

module Bool: Bool

module Buffer: Buffer

module Bytes: Bytes

module BytesLabels: BytesLabels

module Callback: Callback

module Char: Char

module Complex: Complex

module Condition: Condition

module Digest: Digest

module Domain: Domain

module Dynarray: Dynarray

module Effect: Effect

module Either: Either

module Ephemeron: Ephemeron

module Filename: Filename

module Float: Float

module Format: Format

module Fun: Fun

module Gc: Gc

module Hashtbl: Hashtbl

module In_channel: In_channel

module Int: Int

module Int32: Int32

module Int64: Int64

module Lazy: Lazy

module Lexing: Lexing

module List: List

module ListLabels: ListLabels

module Map: Map

module Marshal: Marshal

module MoreLabels: MoreLabels

module Mutex: Mutex

module Nativeint: Nativeint

module Obj: Obj

module Oo: Oo

module Option: Option

module Out_channel: Out_channel

module Parsing: Parsing

module Printexc: Printexc

module Printf: Printf

module Queue: Queue

module Random: Random

module Result: Result

module Scanf: Scanf

module Semaphore: Semaphore

module Seq: Seq

module Set: Set

module Stack: Stack

module StdLabels: StdLabels

module String: String

module StringLabels: StringLabels

module Sys: Sys

module Type: Type

module Uchar: Uchar

module Unit: Unit

module Weak: Weak