• 参照、更新可能レコードと配列
• 制御構造
• 例外処理
• チャネルを使った入出力
• Objective Caml の文法について補足
• 練習問題

# print_string "Hello, World!\n";;
Hello, World!
- : unit = ()

# read_line ();;
foo           ⇐ キーボードからの入力
- : string = "foo"

⟨ 式1 ⟩ := ⟨ 式2 ⟩ 

# let p = ref 5 and q = ref 2;;
val p : int ref = contents = 5
val q : int ref = contents = 2
# (!p, !q);;
- : int * int = (5, 2)
# p := !p + !q;;
- : unit = ()
# (!p, !q);;
- : int * int = (7, 2)

# let reflist = [p; q; p];;
val reflist : int ref list = [contents = 7; contents = 2; contents = 7]
# p := 100;;
- : unit = ()
# reflist;;
- : int ref list = [contents = 100; contents = 2; contents = 100]

# let refp = ref p and refq = ref q;;
val refp : int ref ref = contents = contents = 100
val refq : int ref ref = contents = contents = 2
# !refq := !(!refp);;
- : unit = ()
# (!p, !q);;
- : int * int = (100, 100)

# type teacher = {name : string; mutable office : string};;
type teacher =  name : string; mutable office : string; 
# let t = {name = "Igarashi"; office = "140"};;
val t : teacher = name = "Igarashi"; office = "140"

⟨ 式1 ⟩.⟨ フィールド名 ⟩ <- ⟨ 式2 ⟩

# t.office <- "142";;
- : unit = ()
# t;;
- : teacher = name = "Igarashi"; office = "142"

[|⟨ 式1 ⟩; ⟨ 式2 ⟩; ...; ⟨ 式n ⟩|]
⟨ 式1 ⟩.(⟨ 式2 ⟩)
⟨ 式1 ⟩.(⟨ 式2 ⟩) <- ⟨ 式3 ⟩

# let x = ref [];;
val x : 'a list ref = {contents=[]}

# (2 :: !x, true :: !x);;
- : int list * bool list = ([2], [true])

# x := [1];;
- : unit = ()

# true :: !x;;
??

# let (get, set) =
    let r = ref [] in
    ((fun () -> !r), (fun x -> r:=x));;
val get : unit -> 'a list = <fun>
val set : 'a list -> unit = <fun>
# 1 :: get ();;
- : int list = [1]
# "abc" :: get ();;
- : string list = ["abc"]
# put ["abc"];;
- : unit = ()
# 1 :: get ();;
??

• 変数
• 整数や文字列などの定数
• fun, function などの関数 (匿名関数に限らず let f x = ... として定義されたものも関数である．)
• コンストラクタを値に適用したもの，各要素が値であるレコード/組

• 関数適用，特に ref の適用
• if, match 式

• 内部状態は(整数)座標値 x．
• 座標値を取り出すための get メソッド
• 座標値を更新するための set メソッド
• 座標値を +1 するための inc メソッド

# type pointI = {get: unit -> int; set: int -> unit; inc: unit->unit};;
type pointI =  get : unit -> int; set : int -> unit; inc : unit -> unit; 

# let p = 
#   let x = ref 0 in
#   let rec this () =
#     {get=  (fun () -> !x); 
#      set=  (fun newx -> x:=newx);
#      inc= (fun () -> (this ()).set ((this ()).get () + 1))} in
#   this ();;
val p : pointI = get = <fun>; set = <fun>; inc = <fun>
# p.get();;
- : int = 0
# p.inc();;
- : unit = ()
# p.get();;
- : int = 1

# let pointC x =
#   let rec this () =
#     {get=  (fun () -> !x); 
#      set=  (fun newx -> x:=newx);
#      inc= (fun () -> (this ()).set ((this ()).get () + 1))} in
#   this ();;
val pointC : int ref -> pointI = <fun>
# let new_point x = pointC (ref x);;
val new_point : int -> pointI = <fun>
# let p = new_point 2;;
val p : pointI = get = <fun>; set = <fun>; inc = <fun>
# p.inc(); p.get();;
- : int = 3

# let x = print_string "Hello, " in
# print_string "World!\n";;
Characters 5-6:
 let x = print_string "Hello, " in
 ^
Warning Y: unused variable x.
Hello, World!
- : unit = ()

# let f x y = 2 in
# f (print_string "Hello, ") (print_string "World\n");;
World
Hello, - : int = 2
# (print_string "Hello, ", print_string "World\n");;
World
Hello, - : unit * unit = ((), ())

⟨ 式1 ⟩; ⟨ 式2 ⟩; ⋯; ⟨ 式n ⟩

# ignore;;
- : 'a -> unit = <fun>
# let print_hello () = print_string "Hello, "; 0;;
val print_hello : unit -> int = <fun>
# print_hello (); print_string "World";;
Characters 0-14:
Warning S: this expression should have type unit.
 print_hello (); print_string "World";;Hello, World- : unit = ()
# ignore (print_hello ()); print_string "World\n";;
Hello, World
- : unit = ()

while ⟨ 式1 ⟩ do ⟨ 式2 ⟩ done

for ⟨ 変数名 ⟩ = ⟨ 式1 ⟩ to ⟨ 式2 ⟩ do ⟨ 式3 ⟩ done

for ⟨ 変数名 ⟩ = ⟨ 式1 ⟩ downto ⟨ 式2 ⟩ do ⟨ 式3 ⟩ done

# let parrot () =
#   let s = ref "" in
#     while (s := read_line (); !s <> ".") do
#       print_string !s;
#       print_endline !s;
#     done;;
val parrot : unit -> unit = <fun>

# hd [];;
Exception: Match_failure ("", 66, 7).
# open_in "";;
Exception: Sys_error ": No such file or directory".
# print_string (string_of_int (4 / 0)); print_string "not printed";;
Exception: Division_by_zero.

# exception Foo;;
exception Foo

# raise Foo;;
Exception: Foo.

# let f () = if raise Foo then raise Foo else 3;;
val f : unit -> int = <fun>

# exception Bar of int;;
exception Bar of int
# raise (Bar 2);;
Exception: Bar 2.

# let exnlist = [Bar 3; Foo];;
val exnlist : exn list = [Bar 3; Foo]
# let f = function 
#     Foo -> 0
#   | x -> raise x;;
val f : exn -> int = <fun>
# f Foo;;
- : int = 0
# f (Bar 4);;
Exception: Bar 4.

標準ライブラリの例外

# let rec assoc a = function
#    [] -> raise Not_found
#  | (a', b) :: rest -> if a = a' then b else assoc a rest;;
val assoc : 'a -> ('a * 'b) list -> 'b = <fun>
# assoc "Osaka" city_phone;;
- : string = "06"
# assoc "Nara" city_phone;;
Exception: Not_found.

# failwith "foo";;
Exception: Failure "foo".

try ⟨ 式 ⟩ with
    ⟨ パターン1 ⟩ -> ⟨ 式1 ⟩
  | ...
  | ⟨ パターンn ⟩ -> ⟨ 式n ⟩

# try 4 + 3 with Division_by_zero -> 9;;
- : int = 7
# try 1 + (3 / 0) with Division_by_zero -> 9;;
- : int = 9
# try 1 + (3 / 0) with Sys_error s -> int_of_string s;;
Exception: Division_by_zero.
# let query_city_phone c = 
#   try assoc c city_phone with Not_found -> "999";;
val query_city_phone : string -> string = <fun>
# query_city_phone "Osaka";;
- : string = "06"
# query_city_phone "Nara";;
- : string = "999"

# let rec prod_list = function
#     [] -> 1
#   | n :: rest -> n * prod_list rest;;
val prod_list : int list -> int = <fun>
# prod_list [2; 3; 4];;
- : int = 24
# prod_list [4; 0; 2; 3; 4];;
- : int = 0

# let rec prod_list = function
#     [] -> 1
#   | 0 :: _ -> 0
#   | n :: rest -> n * prod_list rest;;
val prod_list : int list -> int = <fun>

# let rec prod_list_aux = function
#     [] -> Some 1
#   | 0 :: _ -> None
#   | n :: rest -> 
#       (match prod_list_aux rest with None -> None | Some m -> Some (m * n));;
val prod_list_aux : int list -> int option = <fun>
# let prod_list l = match prod_list_aux l with None -> 0 | Some n -> n;;
val prod_list : int list -> int = <fun>
# prod_list [2; 3; 4];;
- : int = 24
# prod_list [4; 0; 2; 3; 4];;
- : int = 0

# exception Zero_found;;
exception Zero_found
# let rec prod_list_aux = function
#     [] -> 1
#   | 0 :: _ -> raise Zero_found
#   | n :: rest -> n * prod_list_aux rest;;
val prod_list_aux : int list -> int = <fun>
# let prod_list l = try prod_list_aux l with Zero_found -> 0;;
val prod_list : int list -> int = <fun>
# prod_list_aux [2; 3; 4];;
- : int = 24
# prod_list_aux [4; 0; 2; 3; 4];;
Exception: Zero_found.
# prod_list [2; 3; 4];;
- : int = 24
# prod_list [4; 0; 2; 3; 4];;
- : int = 0

標準入出力，標準エラー出力関連の関数

ファイル操作とチャネル

# (stdin, stdout, stderr);;
- : in_channel * out_channel * out_channel = (<abstr>, <abstr>, <abstr>)

if false then print_string "a"; print_string "b";;

(if false then print_string "a"); print_string "b";;

if false then print_string "a"; print_string "b" else ();;

if a then if b then c else d

if a then (if b then c else d)

match e with
  A -> match e' with B -> ... | C -> ...
| D -> ...

match e with
  A -> (match e' with B -> ... | C -> ...)
| D -> ...

type 'a ref = { mutable contents : 'a };;

# let x = ref 3;;
val x : int ref = contents = 3
# incr x;;
- : unit = ()
# !x;;
- : int = 4

# let f = ref (fun y -> y + 1)
# let funny_fact x = if x = 1 then 1 else x * (!f (x - 1));;
val f : (int -> int) ref = contents = <fun>
val funny_fact : int -> int = <fun>
# f := funny_fact;;
- : unit = ()
# funny_fact 5;;
- : int = 120

let fact_imp n =
  let i = ref n and res = ref 1 in
    while (...) do 
      ...;
      i := !i - 1
    done;
    ...;;

# type color = Blue | Red | Green | White;;
type color = Blue | Red | Green | White
# type cpointI = {cget: unit -> int; 
#                 cset: int -> unit;
#                 cinc: unit->unit;
#                 getcolor: unit-> color};;
type cpointI = 
 cget : unit -> int;
 cset : int -> unit;
 cinc : unit -> unit;
 getcolor : unit -> color;

# let cpointC x col=
#   let super = pointC x in
#   let rec this =
#     {cget=  super.get;
#      cset=  (fun x -> super.set x; col := White);
#      cinc= super.inc;
#      getcolor = (fun () -> !col)} in
#   this;;
val cpointC : int ref -> color ref -> cpointI = <fun>
# let new_cpoint x col = cpointC (ref x) (ref col);;
val new_cpoint : int -> color -> cpointI = <fun>

# let cp = new_cpoint 0 Red;;
val cp : cpointI =
 cget = <fun>; cset = <fun>; cinc = <fun>; getcolor = <fun>
# cp.cinc();;
- : unit = ()
# cp.cget();;
- : int = 1
# cp.getcolor();;
- : color = Red

# let pointC x this () =
#   {get=  (fun () -> !x); 
#    set=  (fun newx -> x:=newx);
#    inc= (fun () -> (this ()).set ((this ()).get () + 1))};;
val pointC : int ref -> (unit -> pointI) -> unit -> pointI = <fun>
# let new_point x = 
#   let x = ref x in 
#   let rec this () = pointC x this () in
#   this ();;
val new_point : int -> pointI = <fun>

# let rec change = function
#     (_, 0) -> []
#   | ((c :: rest) as coins, total) -> 
#       if c > total then change (rest, total)
#       else c :: change (coins, total - c);;
Warning P: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
([], 1)
 .................function
 (_, 0) -> []
 | ((c :: rest) as coins, total) -> 
 if c > total then change (rest, total)
 else c :: change (coins, total - c)..
val change : int list * int -> int list = <fun>

# let us_coins = [25; 10; 5; 1]
# and gb_coins = [50; 20; 10; 5; 2; 1];;
val us_coins : int list = [25; 10; 5; 1]
val gb_coins : int list = [50; 20; 10; 5; 2; 1]
# change (gb_coins, 43);;
- : int list = [20; 20; 2; 1]
# change (us_coins, 43);;
- : int list = [25; 10; 5; 1; 1; 1]

# change ([5; 2], 16);;
Exception: Match_failure ("", 201, 17).

let rec change = function
    (_, 0) -> []
  | ((c :: rest) as coins, total) -> 
      if c > total then change (rest, total)
      else 
        (try 
          c :: change (coins, total - c) 
         with Failure "change" -> ...)
  | _ -> ...;;

1

Objective Caml のオブジェクト はレコードではないので，そのような制限はもちろんない