アンチノミー

A Learning Note of Bopomofo for Pinyin Users

Qijia Fan — Wed, 22 Apr 2026 00:00:00 GMT

Author: Qijia Fan

本文是为了帮助习惯使用汉语拼音的读者学习注音符号而写的学习笔记，希望能让读者更好地了解汉字标音系统的发展历史与发音逻辑。

背景

注音符号（Bopomofo）是由清末民初的语言学家设计的一套用于标注汉字读音的符号系统，于 1918 年由当时教育部正式颁布。其英文名称「Bopomofo」取自前四个符号的读音：ㄅ（b）、ㄆ（p）、ㄇ（m）、ㄈ（f）。目前的使用情况大致如下：

在中国大陆，注音符号自 1958 年起逐步由汉语拼音取代，但在字典等工具书中仍有标注。以个人观察而言，大陆部分建国前后出生的长辈仍能辨识并使用注音符号，年轻一代则对此较为陌生。
在台湾地区，注音符号至今仍广泛应用于学校教育与日常生活。

注音符号表与拼读

注音符号表由声母、介母、韵母和声调符号组成，其中介母与韵母在汉语拼音中合称为韵母。接下来我们分别给出注音符号表与汉语拼音的对应关系，并说明一些拼读规则。

声母

接下来的两个表格依照注音符号在注音键盘上的排列顺序排列，共 6 + 5 列（栏），每一列（栏）的表头表示该列（栏）的第一个符号在注音键盘上的位置（参见下一节）。

`1`	`2`	`3`	`4`	`5`	`6`
ㄅ b	ㄉ d			ㄓ zh(i)
ㄆ p	ㄊ t	ㄍ g	ㄐ j	ㄔ ch(i)	ㄗ z(i)
ㄇ m	ㄋ n	ㄎ k	ㄑ q	ㄕ sh(i)	ㄘ c(i)
ㄈ f	ㄌ l	ㄏ h	ㄒ x	ㄖ r(i)	ㄙ s(i)

介母与韵母

`7`	`8`	`9`	`0`	`-`
	ㄚ a	ㄞ ai	ㄢ an	ㄦ er
ㄧ y/i	ㄛ o	ㄟ ei	ㄣ en
ㄨ w/u	ㄜ e	ㄠ ao	ㄤ ang
ㄩ yu/ü	ㄝ ê	ㄡ ou	ㄥ eng

在上表中，7 列为介母，其余的列为韵母。

读者可能会注意到，部分汉语拼音中的韵母（如 in(g), ong 等）并未在上表中出现，而这些韵母在注音符号中是由介母与韵母组合而成的，具体见之后的拼读规则说明第 3 条。

声调

注音符号的声调标注与汉语拼音略有不同。在汉语拼音中，阴平、阳平、上声、去声分别用「ˉ」「ˊ」「ˇ」「ˋ」四个符号标注，未标注声调符号表轻声；而在注音符号中，阳平、上声、去声仍用「ˊ」「ˇ」「ˋ」符号标注，但阴平通常不标注声调符号「ˉ」，而轻声需用「˙」符号标注：

标音系统	阴平	阳平	上声	去声	轻声
汉语拼音	ā	á	ǎ	à	a
注音符号	ㄚˉ/ㄚ	ㄚˊ	ㄚˇ	ㄚˋ	ㄚ˙

拼读规则说明

该系统区分两种 i：[i] 与 [ɨ]（例如 si），后者直接用声母（不应在后加「ㄧ」）。

例：「智」的注音为「ㄓˋ」而非「ㄓㄧˋ」。
ㄝ（ê）是 /ɛ/，如「欸」「诶」等，也是 -ei, -ie/ye, -üe/yue 中 e 的实际发音，故 -ie/ye, -üe/yue 的注音分别为「ㄧㄝ」「ㄩㄝ」。

例：「谢」的注音为「ㄒㄧㄝˋ」而非「ㄒㄧㄜˋ」。
-ian/yan, -üan/yuan 的注音还是「ㄧㄢ」「ㄩㄢ」，可以理解为汉语拼音与注音符号系统均不区分 an 与 "ên"。
-in/yin, -ing/ying, -ong, -iong/yong 应分别理解为 -ien（ㄧㄣ）, -ieng（ㄧㄥ）, -ueng（ㄨㄥ）, -üeng（ㄩㄥ）。

例：「红」的拼音和注音分别为「hóng」「ㄏㄨㄥˊ」；「穷」的拼音和注音分别为「qióng」「ㄑㄩㄥˊ」。
iu, ui, un (ün) 分别是 iou, uei, uen (üen) 的缩略形式。

注音输入法

注音输入法的键位排列与注音符号表的排列顺序高度一致，见下图：

其中，3、4、6、7 四个键位呼应了上一节注音符号表中的预留空格，用于输入声调，阴平则用 Space 键输入（对应不标注声调符号）。

TODO

Scribbles-2 OCaml Types

Shen, 1024th — Tue, 24 Feb 2026 00:00:00 GMT

Notes on pattern matching

Patterns that everyone likes. The let expression is actually doing a pattern matching. Consider the dynamic semantics of let p = e1 in e2. We first evaluate e1 to a value v1. The p can be any pattern, and we match v1 with pattern p. If they doesn't match, there will be a Match_failure, otherwise it matches and generates bindings (emmm perhaps no bindings are produced because I can write super weird let in the following). These bindings will be used for substitutions in e2, generating another e2' and evluates to v2.

let 5 = 5 in 6;;

(* Line 1, characters 4-5:
Warning 8 [partial-match]: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
0

- : int = 6 *)

let 5 = 8 in 6;;

(* Line 1, characters 4-5:
Warning 8 [partial-match]: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
0

Exception: Match_failure ("//toplevel//", 1, 4). *)

Types of OCaml

Variants

Variants are like enums in C. Variants are data types, and the value of expressions in this type is exactly one of the defined values.

type day = Sun | Mon | Tue | Wed | Thu | Fri | Sat
let d = Tue
let int_of_day d =
  match d with
  | Sun -> 1
  | Mon -> 2
  | Tue -> 3
  | Wed -> 4
  | Thu -> 5
  | Fri -> 6
  | Sat -> 7

The definition of variants is also shadowing in different scopes.

type t1 = C | D
type t2 = D | E
let x = D
(* val x : t2 = D *)

Records

A record is a composite of other types of data, and forming a new type. The pattern matching {day; food; amount} is sugar for {day = date; food = menu; amount = int}.

type date = Mon | Tue | Wed| Thu;;
(* type date = Mon | Tue | Wed | Thu *)
type menu = Chicken | Beef | Fish;;
(* type menu = Chicken | Beef | Fish *)
type plan = { day : date; food: menu; amount: int};;
(* type plan = { day : date; food : menu; amount : int; } *)
{day = Mon; food = Beef; amount = 10};;
(* - : plan = {day = Mon; food = Beef; amount = 10} *)
let p = {day = Tue; food = Fish; amount = 1};;
(* val p : plan = {day = Tue; food = Fish; amount = 1} *)
p.food;;
(* - : menu = Fish *)
match p with {day; food; amount} -> amount;;
(* - : int = 1 *)

Tuples

Tuples are a composite of other types of data. But the components are not named, they are identified by position. We can also explicitly write a tuple's type using the syntax * (which is actually doing type synonyms of already existing types).

(1,"hello",true);;
(* - : int * string * bool = (1, "hello", true) *)
match (1,"hello",true) with (x,y,z) -> (string_of_int x) ^ y ^ (string_of_bool z);;
(* - : string = "1hellotrue" *)
type tup = int * int * bool;;
(* type tup = int * int * bool *)

Tagged union

We can take a union of two types and give it one name, or view one type as a union with two tags. Inside this union, the new tags we design can tell us which subset a value comes from.

type string_or_int =
  | Str of string
  | Int of int

type colored_int =
  | Blue of int
  | Pink of int

Then we can discriminate the tagged values even they are the same original type.

let increment_pink = function
  | Blue i -> i
  | Pink i -> i + 1

The syntax is like below, [] means optional.

type t = C1 [of t1] | ... | Cn [of tn]

If a Ci is constant, i.e. a tag without different values, then you can write an expression just with Ci; else if it's non-constant, like Ci of string, then we should write an expression as Ci e, e.g. Ci "hello".

The dynamic semantics have one subtle thing: If t = ... | C of t' | ..., then any expression of type t' also has the variant type t, can be viewed as a C e expression, i.e. if e : t' then C e : t.

And in the pattern matching, the non-constant expression is matched by C p. Examples can be find in next section (area and center).

Algebraic data type

Variants are one-of types, also called sum types. Records and tuples are each-of types (Cartesian products). also called product types. Algebraic data types contain both sum types and product types, e.g. the typical example, we first define a pair (each of, product type), then define a tagged union with three tags (one of, sum type), and in some tags, we use the tuple (or pair) again (product type).

type point = float * float
type shape =
  | Point of point
  | Circle of point * float (* center and radius *)
  | Rect of point * point (* lower-left and upper-right corners *)

let area = function
  | Point _ -> 0.0
  | Circle (_, r) -> Float.pi *. (r ** 2.0)
  | Rect ((x1, y1), (x2, y2)) ->
      let w = x2 -. x1 in
      let h = y2 -. y1 in
      w *. h

let center = function
  | Point p -> p
  | Circle (p, _) -> p
  | Rect ((x1, y1), (x2, y2)) -> ((x2 +. x1) /. 2.0, (y2 +. y1) /. 2.0)

In the algebraic data type, "one-of" means the a value of a variant is formed by one of the constructors, while "each-of" means the constructors can have tuples or records, whose value have a sub-value from each of their component types.

The variant type is a collection of constructors. The constructor here serves as both a formation of a value a tag (like a sub-type in this variant type). Variant types are also called tagged unions.

Variant types can be defined recursively by mentioning their own name inside constructors.

type intlist = Nil | Cons of int * intlist
let lst3  = Cons (3, Nil) (* a pair of type int * list *)
let lst123 = Cons (1, Cons (2, Cons (3, Nil)))

Types may be mutually recursive if you use the and keyword:

type node = {value : int; next : mylist}
and mylist = Nil | Node of node

But such mutual recursion must have at least one type that can end, otherwise it will be cyclic and cause an error.

type t = u and u = t
(* File "[12]", line 1, characters 0-10:
1 | type t = u and u = t
    ^^^^^^^^^^
Error: The type abbreviation t is cyclic:
         t = u,
         u = t *)

Record type can also be recursive. The textbook give such an example:

type node = {value : int; next : node}

But this type is not useful. The only values we can create from this type must refer back to itself in a loop because this recursion doesn't end.

let rec n = {value = 1; {value = 2; {value = 3; n}}}

Remark from 1024th: coinductive

Variant type can have type parameters.

type 'a mylist = Nil | Cons of 'a * 'a mylist
let lst3 = Cons (3, Nil)

If we write functions for such parameterized types, we may want to ensure that the 'a type annotation can be omitted safely, that is we don't use operations that are specific to some types, like int or string. (polymorphism) Otherwise, we will give up polymorphism by restricting what 'a can be.

(directly from book) There’s another kind of variant in OCaml that supports this kind of programming: polymorphic variants. Polymorphic variants are just like variants, except:

You don’t have to declare their type or constructors before using them.

There is no name for a polymorphic variant type. (So another name for this feature could have been “anonymous variants”.)

The constructors of a polymorphic variant start with a backquote character. Using polymorphic variants, we can rewrite f:

let f = function
  | 0 -> `Infinity
  | 1 -> `Finite 1
  | n -> `Finite (-n)
(* val f : int -> [> `Finite of int | `Infinity ] = <fun> *)

And f returns a value of type 'Finite or 'Infinity. The backquote is still there.

Option

An option is actually a one-of type, it can be either having an element (e.g. an option Some 22, which has type int option) or being empty (an option None, which has type 'a option). But option itself is not a type, it produce a new type t option from any type t.

let rec list_max = function
  | [] -> None
  | h :: t -> begin
      match list_max t with
        | None -> Some h
        | Some m -> Some (max h m)
      end

The type will be val list_max : 'a list -> 'a option = <fun>. And the begin and end is equivalent to () in functionality.

OCaml options force the programmer to include a branch in the pattern match for None, thus guaranteeing that the programmer thinks about the right thing to do when there’s nothing there. So we can think of options as a principled way of eliminating null from the language.

None is a value of type 'a option.

Some e is an expression of type t option if e : t. If e ==> v then Some e ==> Some v

Association lists

Map maps keys to values. In OCaml it can be trivially implemented in association list, which is a list of pairs with constant insertion time and linear lookup time.

let mymap : (string * int) list =
  [("Level 1", 128); ("Level 2", 192); ("Level 3", 256)];;
let insert k v lst = (k, v) :: lst;;
let rec lookup k = function
  | [] -> None
  | (k', v) :: t -> if k = k' then Some v else lookup k t;;
lookup "Level 1" mymap;;
(* - : int option = Some 128 *)

The standard library implements association lists with List module. Module names in OCaml use CamelCase, and function names use snake_case.

val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc
val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc

The fold_left is of type List.fold_left : ('b -> 'a -> 'b) -> 'b -> 'a list -> 'b. so it takes three arguments fold_left f init list

the first argument f: is a function, like the operator +, or the Cons. It takes the current accumulator of type 'b, takes one element of type 'a, do the operation to get a new accumulated value of type 'b.
the second argument is the initial accumulator
the third argument is a list, we want to do the operation f from the left side of the list. fold_left is tail-recursive while the fold_right is not, because the head can be popped out from left side in $O(1)$ time.

Quality of life in OCaml

OUnit

Unit tests framework for OCaml: OUnit Configure the dune project with dune

(executable
 (name test)
 (libraries ounit2))

Write a random mycode.ml file for invoking.

let ask_ds x = match x with
  | "good ds" -> "Thanks"
  | "sleepy ds" -> "OK"
  | "bad ds" -> "No"
  | _ -> failwith "Not in Dictionary"

Use the code an run a unit test. Each test case has a string giving it a descriptive name, and a function to run as the test case. In between is a custom operator >::. >::: is in between of the name of this test suite and the test cases.

open OUnit2
open Mycode

let tests = "test suit for asking ds" >::: [
  "say thanks" >:: (fun _ -> assert_equal "Thanks" (ask_ds "good ds"));
  "say no" >:: (fun _ -> assert_equal "No" (ask_ds "bad ds"));
  "say zzz" >:: (fun _ -> assert_equal "ZZZ" (ask_ds "sleepy ds") ~printer:(fun x -> x)); (* ~printer is an argument. Get `expected: ZZZ but got: OK` *)
  "say bye" >:: (fun _ -> assert_equal "Bye" (ask_ds "bye ds"))
]

let _ = run_test_tt_main tests

The output will be like

Error: test suit for asking ds:3:say bye.
Failure("Not in Dictionary")

Error: test suit for asking ds:2:say zzz.
expected: ZZZ but got: OK

Scribbles-1 Basics of OCaml

Shen, 1024th — Sat, 31 Jan 2026 00:00:00 GMT

The properties of OCaml

First-Class Citizens

OCaml is a statically-typed and type-safe programming language.

A statically-typed language detects type errors at compile time; if a type error is detected, the language won’t allow execution of the program.

A type-safe language limits which kinds of operations can be performed on which kinds of data. Python is type-safe but dynamically typed. That is, type errors are caught only at run time. C and C++, are statically typed but not type safe: they check for some type errors, but don’t guarantee the absence of all type errors. That is, there’s no guarantee that a type error won’t occur at run time.

C++ is not totally type safe. malloc/free will return pointer of void *

int x = 10;
char* p = reinterpret_cast<char*>(&x);

Algebraic data types
[[Type inference]]: we have to ensure the program is correctly written for the compiler to do type inference. You can annotate types but cannot cast them. (5 : int) (5. : int)
Parametric polymorphism: functions and data structures can be parameterized over types, functioning like the template<typename T> in C++. But C++ templates are (mostly) instantiated and type-checked per use, while OCaml’s polymorphic functions are type-checked once at definition. In C++, a template definition can be accepted even if some operations inside it would be ill-formed for certain T; errors typically appear only when C++ makes an instantiation with a specific type substitution and it is incompatible with the template, so the runtime is good while compilation is slow. OCaml compilation directly does type-checking at the definition, to ensure the template to be a general, abstract type (it must holds for every type, so type-specific operations like +1 fails right away), then does the substitution at run time. So OCaml is value agnostic. The check is supported by Hindley–Milner style type inference/unification.
Garbage collection
Modules

OCaml Basics

Syntax
Semantics
1. type-checking rules (static semantics): produce a type or fail with an error
2. evaluation rules (dynamic semantics) OCaml does type-checking at compile time like Java and C++, while Python at runtime.

Compile a file, run and clear

ocamlc - o hello.byte hello.ml
./hello.byte
rm hello.byte hello.cmi hello.cmo

Or use dune at ease dune: (executable (name hello)) dune-project: (lang dune 3.21)

dune build hello.exe
_build/default/hello.exe
dune exec ./hello.exe
dune clean

dune init project auto_hello
cd auto_hello
dune exec bin/main.exe

OCaml's toplevel is called utop as a calculator+command-line interface (utop is so luxury, even with tab completion and syntax highlighting), some other languages call the toplevel a REPL. Like JShell for Java and interactive interpreter for Python. It's working logic is Read-Eval-Print Loop. Typically when we write OCaml in a .ml file we don't need ;;. It's only needed when we write in a interactive session like utop. The toplevel reads until hitting one ;; to know that OK this is one chunk of input (a toplevel phrase). So ;; means where phrase is complete and ready for parsing and evaluation.

#quit;; (* quitting utop. start with another "#" *)
42;;
(* - : int = 42 *)

Expression

OCaml integers are represented as 63 bits, using one bit in the 64-bit word as a mark of integer (distinguishing from pointer, which is for garbage collection) (previously it's 31 bits). OCaml floats are float64. Syntactically, they must always contain a dot and the addition, division and multiplication of floats must also has a dot +. /. *. . Char takes 1 byte. String is sequence of chars. OCaml values don't have methods like C++ to convert themselves to strings, but we can use string_of_xxx. operator lsr is logical shift right, while asr is arithmetic shif right. asr fills the left with sign bit while lsr fills with 0s.

3.14 *. (float_of_int 2);;
(* - : float = 6.28 *)
(int_of_float 3.14) * 2;;
(* - : int = 6 *)
char_of_int(5);;
(* - : char = '\005' *)
int_of_char('t');;
(* - : int = 116 *)
string_of_float(3.33);;
(* - : string = "3.33" *)
"abcd".[0];;
(* - : char = 'a' *)
-40 lsr 2;;
(* - : int = 2305843009213693942 *)
-40 asr 2;;
(* - : int = -10 *)
2305843009213693942 lsl 2;;
(* - : int = -40 *)
"str" ^ "ing";;
(* - : string = "string" *)
[2,3];;
(* - : (int * int) list = [(2, 3)] *) (* list of pairs *)
[1,2] @ [3,4];;
(* - : (int * int) list = [(1, 2); (3, 4)] *)

OCaml also has references. They are expressions but they simulates the behavior of variables (Everything is an expression in OCaml). ref 0 is an expression, it evaluates to return a value with type int ref. !r is also an expression, it evalutes to the content referred. r:=5 is assigning value to the reference, and it's also an expression, it evaluates to a value () with type unit.

let r = ref 0;;
(* val r : int ref = {contents = 0} *)
!r;;
(* - : int = 0 *)
r := 1;;
(* - : unit = () *)
let x = if (r:=5; !r > 0) then "hello" else "bye";;
(* val x : string = "hello" *)

Structural Equality = (inequality <>) is for value comparison, which ignores the memory address, like == in python, while physical equality == (inequality !=) compaires memory address, like == between pointers in C/C++.

let r1 = ref 42;;
(* val r1 : int ref = {contents = 42} *)
let r2 = ref 42;;
(* val r2 : int ref = {contents = 42} *)
r1 = r2;;
(* - : bool = true *)
!r1 = !r2;;
(* - : bool = true *)
r1 == r2;;
(* - : bool = false *)
!r1 == !r2;;
(* - : bool = true *)
let r3 = r1;;
(* val r3 : int ref = {contents = 42} *)
r3 == r1;;
(* - : bool = true *)
r3 <> r2;;
(* - : bool = false *)
r3 != r2;;
(* - : bool = true *)

With regard to why !r1 == !r2 is true, OCaml implements a "small integer optimization" ==using tagged pointers to store immediate integer values directly in a single machine word without requiring extra memory allocation (boxing)==. If we use this experiment to heap objects, like floats or lists, it will be false because their addresses are different.

let x = ref 3.14;;
(* val x : float ref = {contents = 3.14} *)
let y = ref 3.14;;
(* val y : float ref = {contents = 3.14} *)
!x == !y;;
(* - : bool = false *)
!x != !y;;
(* - : bool = true *)

It seems that even large integers also has == to be true. That's amasing.

If assertion is true, OCaml returns a value of type unit

assert (1 == 1);;
(* - : unit = () *)
assert (1 == 2);;
(* Exception:
Assert_failure ("//toplevel//", 1, 0). *)

When there is no else the default empty expression is (), so the type-checking fails if there is no else and the then branch'es type is not unit.

if 3 + 5 > 2 then "yay!" else "boo!";;
(* - : string = "yay!" *)
if 'a' > 'b' then ();;
(* - : unit = () *)
if 'a' > 'b' then 2;;
(* Error: The constant 2 has type int
       but an expression was expected of type
         unit
       because it is in the result of a conditional with no else branch *)

The principle of name irrelavance: like $f(x)=x^2$ and $f(y )=y^2$, the name doesn't matter! so we just evaluate the expression according to the priority of parenthenses. Rule: a new binding of a variable shadows any old binding. It’s as if the new binding temporarily casts a shadow over the old binding. But eventually the old binding could reappear as the shadow recedes.of the variable name.

let x = 5 in
  ((let x = 6 in x) + x);;
(* - : int = 11 *)

Shadowing is not mutable assignment. In the following example, each let definition binds an entirely new variable. If that new variable happens to have the same name as an old variable, the new variable temporarily shadows the old one. But the old variable is still around, and its value is immutable.

let x = 42;;
(* val x : int = 42 *)
let f y = x + y;;
(* val f : int -> int = <fun> *)
f 0;;
(* : int = 42 *)
let x = 22;;
(* val x : int = 22 *)
f 0;;
(* - : int = 42  (* x did not mutate! *) *)

OCaml has objects besides values like integers, tuples, lists, records, variants. Object oriented programming (OOP) in OCaml is available but rarely used. OOP organizes data (members and attributes) as objects and describes the object's behavior (methods or functions).

Definition

let x = 42;;
(* val x: int = 42 *)

Definitions are not expressions, nor are expressions definitions. But definitions can have expressions in the syntax. x is an identifier, which should starts with a lower-case letter. let x = e Evaluation:

evaluate expression e to a value v
bind v to x (a memory named x contains v)

Function

Auto type inference

We don't have to write types because the compiler does type inference according to the code itself. (But we can do annotations.)

let increment x = x + 1;;
(* val increment : int -> int = <fun> *)
let rec fact n = if n = 0 then 1 else n * fact (n - 1);;
(* val fact : int -> int = <fun> *)
let rec pow (x : int) (y : int) : int = if y = 0 then 1 else x * pow x (y-1);;

First-class functions

Functions are first-class citizens, having identifier increment, and type int -> int, and value as the function itself (utop prints <fun> as a placeholder). [[Notes from 1024th]]

let x = 1;;
(* val x : int = 1 *)
let f y = x + y;;
(* val f : int -> int = <fun> *)
let res1 = f 2 in (
    let x = 5 in (
    let res2 = f 2 in res1 + 10 * res2
  )
);;
(* Line 2, characters 8-9:
Warning 26 [unused-var]: unused variable x.

- : int = 33 *)

f is a metavariable indicating an identifier being used as a function name, and parameters x are metavariables indicating argument identifiers. These identifiers must begin with a lowercase letter. When a function is defined, OCaml records that the name f is bounded to a function with the given arguments. OCaml functions don't have to have names. We can write a function fun x -> x+1 as a "value" just like we write a number 42 (and this is also called lambda expression). The let function definition is not an expression.

let f1 x = x in (
let f2 x = x in (
f1 = f2 )
);;
(* Exception: Invalid_argument "compare: functional value". *)

let f1 x = x in (
let f2 x = x in (
f1 == f2 )
);;
(* - : bool = false *)

let f1 x = x in (
let f2 = f1 in (
f1 == f2 )
);;
(* - : bool = true *)

f1 和 f2 都是函数（而且各自是不同的闭包值），OCaml 没有定义“两个函数是否相等”的通用语义： - 扩展性问题：就算它们对所有输入返回一样（外延相等），一般也无法在有限时间内判定。 - 语义问题：闭包还可能捕获环境，是否“相等”也不清晰。 因此 OCaml 直接禁止用通用 = 去比函数，并在运行时报错。(AIGC)https://ocaml.org/docs/values-and-functions

Now you have a taste of functions as first-class citizen. Higher-order programming is “more expressive for higher-order abstractions (callbacks, combinators, map/filter-style APIs) because passing behavior as a value is direct" (AIGC).train_rse.ox

Shadowing and scopes

let f x y = x + y;;
(* val f : int -> int -> int = <fun> *)
let f x y = x * y;;
(* val f : int -> int -> int = <fun> *)
f 3 3;;
(* - : int = 9 *)

This not mutable, just shadowing. When you write two functions with the same name, the latter one shadows the former one. And with let ... in and (...) to handle with scope, we can go beyond the shadowed scope and call the former one. (That's 1024th's example.) My experiments:

let n = 10;;
(* val n : int = 10 *)

let f x = x + n;;
(* val f : int -> int = <fun> *)
f 5;;
(* - : int = 15 *)

let n = 20;;
(* val n : int = 20 *)

f 5;;
(* - : int = 15 *)

let f x= x + 3*n;;
(* val f : int -> int = <fun> *)
f 5;;
(* - : int = 65 *)

An example from 1024th:

let f x y = x + y in
let () =
(
  let f x y = x * y in
  Printf.printf "%d\n" (f 3 3)
) in
Printf.printf "%d" (f 3 3);;
(* 9
6- : unit = () *)

Mutually recursive functions

Mutually recursive functions: sometimes functions are mutually recursive, meaning that calls form a circle, where one function calls another which calls the first, with any number of calls in between.

let rec even n =
  n = 0 || odd (n - 1)
and odd n =
  n <> 0 && even (n - 1);;
(* val even : int -> bool = <fun>
val odd : int -> bool = <fun> *)

Static and dynamic semantics

For functions with more than one arguments, they have t1 -> t2 -> u as the type, meaning requiring two inputs, the first of type t1 and the second of type t2, and returns an output of type u.

let f1 x y = x ^ y;;
(* val f1 : string -> string -> string = <fun> *)

Static semantics: e0 : t1 -> ... -> tn -> u, then e1 : t1 and .... e0 e1 ... en: u. Dynamic semantics:

To evaluate e0 e1 ... en:

Evaluate e0 to a function. Also evaluate the argument expressions e1 through en to values v1 through vn. For e0, the result might be an anonymous function fun x1 ... xn -> e or a name f. In the latter case, we need to find the definition of f, which we can assume to be of the form let rec f x1 ... xn = e. Either way, we now know the argument names x1 through xn and the body e.

Substitute each value vi for the corresponding argument name xi in the body e of the function. That substitution results in a new expression e'.

Evaluate e' to a value v, which is the result of evaluating e0 e1 ... en. If you compare these evaluation rules to the rules for let expressions, you will notice they both involve substitution. This is not an accident. In fact, anywhere let x = e1 in e2 appears in a program, we could replace it with (fun x -> e2) e1. They are syntactically different but semantically equivalent. In essence, let expressions are just syntactic sugar for anonymous function application.

Polymorphism

And when the functions without annotations can be adapted to multiple types, it will be written as a an unknown type 'a. And you can assign this function to another function with type specified.

We took a value of type 'a -> 'a, and we bound it to a name whose type was manually specified as being int -> int. This assignment is possible because it doesn't break the promise of id or the anonymous fun x -> x, it just loses some information. It’s always going to be safe to use a function of type 'a -> 'a when what we needed was a function of type int -> int.

let id x = x;;
(* val id : 'a -> 'a = <fun> *)

let id2 : 'a -> 'a = fun x -> x;;
(* val id2 : 'a -> 'a = <fun> (* manually annotate to a general type *) *)

let id_int : int -> int = id;;
(* val id_int : int -> int = <fun> *)

let id_bool : bool -> bool = fun x -> x;;
(* val id_bool : bool -> bool = <fun> *)

let first x y = x;;
(* val first : 'a -> 'b -> 'a = <fun> *)

let first_int : int -> 'a -> int = first;;
(* val first_int : int -> 'a -> int = <fun> *)

let first_str : string -> 'a -> int = first;;
(* Error: The value first has type
         string -> 'a -> string
       but an expression was expected of type
         string -> 'a -> int
       Type string is not compatible with type int *)

Labelled arguments

You can also lable the arguments with ~name:

let first_str : string -> 'a -> int = first;;
(* Error: The value first has type
         string -> 'a -> string
       but an expression was expected of type
         string -> 'a -> int
       Type string is not compatible with type int *)

let sum ~lchild:x ~rchild:y = x + y;;
(* val sum : lchild:int -> rchild:int -> int = <fun> *)

sum 7 8;;
(* Without specifying the names, there will be warnings *)
(* Line 1, characters 0-3:
Warning 6 [labels-omitted]: labels lchild, rchild were omitted in the application of this function.

Line 1, characters 0-3:
Warning 6 [labels-omitted]: labels lchild, rchild were omitted in the application of this function.

- : int = 15 *)

sum ~lchild:4 ~rchild:5;;
(* - : int = 9 *)

let echo ~str:(x : string) = x;;
(* val echo : str:string -> string = <fun> *)

Optional arguments

Optional argument with default value. Then the name of the optional argument cannot be skipped.

 let step ?default_arg: (x=1) y = x + y;;
(* val step : ?default_arg:int -> int -> int = <fun> *)

step 2 0;;
(* Error: The function applied to this argument has type
         ?default_arg:int -> int
This argument cannot be applied without label *)

step ~default_arg:2 0;;
(* - : int = 2 *)
step 0;;
(* - : int = 1 *)

Partial application

OCaml allows partial application.

let add x = fun y -> x + y;;
(* val add : int -> int -> int = <fun>
   (* Semantically equivalent to `let add x y = x + y` *)
   (* Also equivalent to `let add = fun x -> (fun y -> x + y)` *) *)
addx 5;;
(* - : int -> int = <fun> *)

Functiona Associativity

Every OCaml function takes exactly one argument. Even though you think of f as a function that takes n arguments, in reality it is a function that takes 1 argument and returns a function. The type of a function should be t1 -> (t2 -> (t3 -> t4)), which is, function types are right associative: there are implicit parentheses around function types, from right to left. The intuition here is that a function takes a single argument and returns a new function that expects the remaining arguments. Function application, on the other hand, is left associative, where e1 e2 e3 e4 is acutally ((e1 e2) e3) e4.

Define new operators

Built-in infix operators are acutally implemented as functions.

let ( ^^ ) x y = max x y

Pipelines

let inc x = x + 1;;
(* val inc : int -> int = <fun> *)
let square x = x * x;;
(* val square : int -> int = <fun> *)
inc (square 6);;
(* - : int = 37 *)
6 |> square |> inc;;
(* - : int = 37 *)

Tail-call optimization

OCaml also implement function calls in a stack.

let rec count n =
  if n = 0 then 0 else 1 + count (n - 1);;

let rec count_aux n acc =
  if n = 0 then acc else count_aux (n - 1) (acc + 1);;
let count_tr n = count_aux n 0;; (* tr for tail recursion *)

A good compiler (and the OCaml compiler is good this way) can notice when a recursive call is in tail position, which is a technical way of saying “there’s no more computation to be done after it returns”. A recursive call in tail position does not need a new stack frame. It can just reuse the existing stack frame. That’s because there’s nothing left of use in the existing stack frame. None of that memory ever needs to be read again, because that call is effectively already finished. This is the tail-call optimization. It can even be applied in cases beyond recursive functions if the calling function’s stack frame is suitably compatible with the callee. > The Recipe for Tail Recursion. In a nutshell, here’s how we made a function be tail recursive:

Change the function into a helper function. Add an extra argument: the accumulator, often named acc.

Write a new “main” version of the function that calls the helper. It passes the original base case’s return value as the initial value of the accumulator.

Change the helper function to return the accumulator in the base case.

Change the helper function’s recursive case. It now needs to do the extra work on the accumulator argument, before the recursive call. This is the only step that requires much ingenuity.

Directives

#use "somefile.ml";; (* in order to load codes in toplevel *)

Exit utop when you want to edit the code in the #use file, because utop runs a single-thread, reloading might cause type-checking error or memory leak.

Documentation

todo

Lists

OCaml list is a sequence of values with the same type, implemented as singly-linked lists. (Suprising name! Yes, linked list: singly linked lists and doubly linked lists). So their implementation is good for sequential access. [e1; e2] is syntatic sugar for e1 :: e2 :: [], consing elements to the nil. Cons is a right associative operator. [] is a value. To evaluate e1 :: e2, we first evaluate e1 to be value v1, and evaluated e2 to be a list value v2, and then return a new list value v1 :: v2. So the cons will have the same list type of e2, and require the prepended element to have type the same as the list elements in e2. If the elements in the list are type t, then the list will be t list. Lists are first-class citizens. They are immutable. so the :: doesn't change the list, it creates a new one by prepending. Immutability it safe for the compiler to perform an optimization. Two lists, if one derived from another, can share some of the memory for optimization and do this safely because they both don't change.

Compare: Cons :: does prepend 'a -> 'a list -> 'a list. Constant time. Append @ does combination 'a list-> 'a list -> 'a list. Linear time of the first list.

[];; (* `[]` type is not determined, `[]` pronounced as nil *)
(* - : 'a list = [] *)
[1];;
(* - : int list =  *)
[1; 2];;
(* - : int list = [1; 2] *)
[1; 1.];;
(* Error: The constant 1. has type float
       but an expression was expected of type int *)
[[1];[2]];;
(* - : int list list = [; ] *)
1 :: 2 :: [];; (* pronounced as cons*)
(* - : int list = [1; 2] *)
"red" :: ["blue"; "green"];;
(* - : string list = ["red"; "blue"; "green"] *)

Pattern Matching

match not true with | true -> "nope" | false -> "yep";;
(* - : string = "yep" *)

let y = match 42 with foo -> foo;;
(* val y : int = 42 *)

let z = match "hello" with | "foo" -> 1 | _ -> 2;;
(* val z : int = 2 *)

let a = match [] with | [] -> "empty" | _ -> "not empty";;
(* val a : string = "empty" *)

let b = match ["111"; "222"] with | [] -> "empty list" | head :: tail -> head;;
(* val b : string = "111" *)

let b = match ["111"; "222"] with | [] -> ["empty list"] | head :: tail -> head;;
(* Error: The value head has type string
       but an expression was expected of type
         string list *)

let first3 t =
 match t with | (a, b, c) -> a;;
(* val first3 : 'a * 'b * 'c -> 'a = <fun> *)

first3 (1, 2, 3);;
(* - : int = 1 *)

fst (1, 2);;
(* - : int = 1 *)

type student = {
 name : string;
 year: int;
}

let rgb = {
 name = "ruth";
 year = 1111;
}

let name_with_year s = match s with
 | {name; year} -> name ^ " " ^ string_of_int year;;
(* type student = { name : string; year : int; }
val rgb : student =
  {name = "ruth"; year = 1111}
val name_with_year : student -> string = <fun> *)

name_with_year rgb;;
(* - : string = "ruth 1111" *)

let test lst = (* let empty lst = (lst = []) *)
    match lst with
    | [] -> true
    | h :: t -> false;;
(* val test : 'a list -> bool = <fun> *)

test [];;
(* - : bool = true *)
test ["aimme"; "cat"];;
(* - : bool = false *)

let test lst =
    match lst with
    | [] -> true
    | _ :: _ -> false;;
(* val test : 'a list -> bool = <fun> *)

let rec sum lst =
    match lst with
    | [] -> 0
    | h :: t -> h + sum t;;
(* val sum : int list -> int = <fun> *)

sum [1; 2; 3; 4; 5];;
(* - : int = 15 *)

#trace sum;;
(* sum is now traced. *)

sum [1; 2; 3;];;
(* sum <-- [1; 2; 3]
sum <-- [2; 3]
sum <-- [3]
sum <-- []
sum --> 0
sum --> 3
sum --> 5
sum --> 6
- : int = 6 *)

#untrace sum;;
(* sum is no longer traced. *)

let rec append lst1 lst2 =
    match lst1 with
    | [] -> lst2
    | h :: t -> h :: append t lst2;;
(* val append : 'a list -> 'a list -> 'a list =
  <fun> *)

append [1; 2] [3; 4; 5];;
(* - : int list = [1; 2; 3; 4; 5] *)
append [1; 2] [];;
(* - : int list = [1; 2] *)

[1; 2] @ [3; 4];;
(* - : int list = [1; 2; 3; 4] *)

List.hd [1.; 2.; 3.;];;
(* - : float = 1. *)
List.tl [1.; 2.; 3.;];;
(* - : float list = [2.; 3.] *)
List.hd [];;
(* Exception: Failure "hd". (* pattern matching is more robust, handling with empty list. *) *)

Like switch statement in C++, but more powerful. Match with some shapes of data, and then extract pieces from the data. Lists are not mutable. Immutable.

Syntacs: here p is pattern expressions (like any identifier, _, any constant value, [], p1 :: p2, (p1, p2), {f1=p1; f2=p2})

match e with
| p1 -> e1
| p2 -> e2

Semantics (evaluation): First evaluate e to v, and find the first pattern pi (top to bottom) that matches v, then evaluate ei to vi and return vi. Patterns: A constant matches itself. An identifier matches anything and binds itself (the name) with the matched value in the scope of the branch. The underscore matches anything and doesn't bind.

If p1 matches v1 and produces a set of bindings, and if p2 matches v2 and produces a set of bindings, then p1 :: p2 matches v1 :: v2 and produces the union set of bindings. Note that v2 must be a list (since it’s on the right-hand side of ::) and could have any length. Note that the union of bindings will never have a problem where the same variable is bound separately in two bindings and because of the syntactic restriction that no variable name may appear more than once in a pattern. 

If for all i in 1..n, it holds that pi matches vi and produces the set of bindings, then [p1; ...; pn] matches [v1; ...; vn] and produces a set of bindings. Note that this pattern specifies the exact length the list must be.

Type-checking (static): all of the patterns and the value that will be matched should the same type. All the expressions in branches should have the same type, and this will be the type of the entire match expression. And the compiler also tests exhaustiveness/exhaustivity and unused branches.

let bad_test lst =
    match lst with
    | [] -> "empty";;

(* Lines 2-3, characters 4-19:
Warning 8 [partial-match]: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
_::_

val bad_test : 'a list -> string = <fun> *)

let rec sum lst =
  match lst with
  | h :: t -> h + sum t
  | [ h ] -> h
  | [] -> 0;;
(* Line 4, characters 4-9:
Warning 11 [redundant-case]: this match case is unused.

val sum : int list -> int = <fun> *)

(* A silly example where the programmer thought the code will check whether n is equal to n. But pattern matching is not checking equality, it matches an identifer pattern with `n`, so it will be always true. Therefore the second branch is unused.*)
let length_is lst n =
  match List.length lst with
  | n -> true
  | _ -> false;;
(* Line 4, characters 4-5:
Warning 11 [redundant-case]: this match case is unused.

val length_is : 'a list -> 'b -> bool = <fun> *)

_ :: [] matches all lists with exactly one element

_ :: _ matches all lists with at least one element

_ :: _ :: [] matches all lists with exactly two elements

_ :: _ :: _ :: _ matches all lists with at least three elements

Syntatic sugar for function keyword

We can skip the last argument and the match with thing if we are doing a pattern matching for the last argument. So here is a rewriting of sum.

let f x y z = match z with
    | [] -> x + y
    | _ -> 0;;
(* val f : int -> int -> 'a list -> int = <fun> *)
let f1 x y = function
    | [] -> x + y
    | _ -> 0;;
(* val f1 : int -> int -> 'a list -> int = <fun> *)
f 2 3 [];;
(* - : int = 5 *)
f1 2 3 [];;
(* - : int = 5 *)

let rec sum = function
    | [] -> 0
    | h :: t -> h + sum t;;
(* val sum : int list -> int = <fun> *)
sum [2; 3];;
(* - : int = 5 *)