カテゴリー: OCaml

次の関数 thrd は3要素のタプルを引数にとって，3番目の要素を返す。

# let thrd (x, y, z) = z;;
val thrd : 'a * 'b * 'c -> 'c = <fun>

この， ‘a，’b，’c を型変数といい，thrd を適用するときには具体的にどんな型がきてもいい。つまり引数のタプルの各要素が，int であっても string であってもそれ以外のどんな型であってもいいってこと。

thrd のように型に関して抽象化された関数を多相的関数という。また，関数の型情報の一部をパラメータ化することによって発生する多相性をパラメトリック多相という。

# thrd ("foo", 2, 3.0);;
- : float = 3.
# thrd ('1', 2.0, (3, "three"));;
- : int * string = (3, "three")

p.67より。

実数上の関数 f に対して定積分 を近似計算する関数 integral f a b を定義しなさい。またこれを使って， を計算しなさい。

近似の方法は台形近似。積分区間を100個の台形に分けて面積を合計する。

# let integral f a b =
let d = (b -. a) /. 100. in
let trapezoid x y z = (x +. y) *. z /. 2. in
let rec area i =
if i = 0. then 0.
else trapezoid (f (a +. d *. (i -. 1.))) (f (a +. d *. i)) d +. area (i -. 1.)
in
area 100.
;;
val integral : (float -> float) -> float -> float -> float = <fun>

あんまりきれいじゃないけどいいか。 + と +. を間違えてて時間がかかった。整数と実数で演算子が違うってのはどうもなれないな。

# let pi = 3.141592;;
val pi : float = 3.141592
# integra sin 0. pi;;
- : float = 1.9998355039556754

前置・中置演算子も一種の関数なので，ふつうの関数と同じように定義できる。ただし，名前を括弧で囲むのと使える文字に制限がある。

# let (^-^) x y = x * 2 + y * 3;;
val ( ^-^ ) : int -> int -> int = <fun>
# 2 ^-^ 3;;
- : int = 13
# 5 ^-^ 9;;
- : int = 37

演算子に使える文字は次の通り。

前置演算子の１文字目：

! ? ~

中置演算子の１文字目：

= < > @ ^ | & + - * / $ %

２文字目：

! $ % * + - . / : < = > ? @ ^ | ~

中置演算子には上記のほかに次のキーワードが使える。

asr land lor lsl lsr lxor mod or !=

また，前置・中置とも次のキーワードは使えない。

#  '  (  )  ,  -> .  .. :  :: :> ;  ;; <- >]
?  ?? [  [< [> [| ]  _  `  {  {< |  |] }  ~

もちろんある。

次の sum_of は 1～n までの整数それぞれに f を適用して合計を求める関数。

# let rec sum_of f n =
if n = 0 then 0 else f n + sum_of f (n-1);;
val sum_of : (int -> int) -> int -> int = <fun>

f は別のところで定義した関数でもいいし，その場限りの匿名関数（無名関数)でもいい。

匿名関数には fun 式を使う。

# sum_of (fun x -> x * x) 5;;
- : int = 55

ほぼ Haskell といっしょ。

OCaml の関数はカリー化されているので，部分適用できる。

# let sum_of_twice = sum_of (fun x -> x * 2);;
val sum_of_twice : int -> int = <fun>
# sum_of_twice 5;;
- : int = 30

末尾再帰的関数を使ってフィボナッチ数を計算する iterfib

# let iterfib n =
let rec fibn (x, y) i =
if i = n then y
else fibn (y, x + y) (i+1)
in
fibn (0, 1) 1
;;
val iterfib : int -> int = <fun>
# iterfib 1;;
- : int = 1
# iterfib 2;;
- : int = 1
# iterfib 3;;
- : int = 2
# iterfib 4;;
- : int = 3
# iterfib 5;;
- : int = 5
# iterfib 6;;
- : int = 8

ちゃんと末尾再起になってるよね？

本文中で与えられた再帰的な定義で n個の中からm個を選ぶ場合の数 を求める関数 comb を定義せよ，という問題。再帰的な定義は本文（p.51）をみること（書くのが面倒なので)。

# let rec comb n m =
if m = 0 then 1
else if n = m then 1
else comb (n-1) m + comb (n-1) (m-1)
;;
val comb : int -> int -> int = <fun>
# comb 5 3;;
# comb 2 1;;
- : int = 2

プログラミング in OCaml ~関数型プログラミングの基礎からGUI構築まで~ p.57より。

if式を OCaml の関数で表現することはできません。次の関数はそれを試みたものですが，fact 4 の計算の評価ステップを考え，なぜうまく計算できないのか説明しなさい。

# let cond (b, e1, e2) : int = if b then e1 else e2;;
val cond : bool * int * int -> int = <fun>
# let rec fact n = cond ( (n = 1), 1, n * fact (n-1) );;
val fact : int -> int = <fun>
# fact 4;;
Stack overflow during evaluation (looping recursion?).

式の評価戦略の説明のところ（pp.46-48）ではわかりにくいけど，要するに OCaml は関数の引数を先に評価する。fact 4 を評価することは cond ( (4=1), 1, 4 * fact (4-1) )を評価するってことで，fact 4 の値を確定する前に fact (4-1)，つまり fact 3 の値を確定しなけりゃならない。同様に fact 3 の前に fact 2 を，fact 2 の前に fact 1 を，fact 1 の前に fact 0 を，fact 0 の前に fact (-1) を･･････(以下略）となって，いつまでたっても値を確定できない。結局スタックオーバフローになった，というわけだ。

ここら辺は Haskell とは違うところだな。遅延評価する Haskell では何の問題も無く動く。

Prelude> let cond (b, e1, e2) = if b then e1 else e2
Prelude> let fact n = cond ((n == 1), 1, n * fact (n - 1))
Prelude> fact 4
24

2つ（あるいはそれ以上）の関数を and でつないでいっぺんに定義できるがおもしろい。

and の後の関数には let rec が要らない。

# let rec even n =
if n = 0 then true else odd (n - 1)
and odd n =
if n = 0 then false else even (n - 1)
;;
val even : int -> bool = <fun>
val odd : int -> bool = <fun>
# even 3;;
- : bool = false
# even 4;;
- : bool = true
# odd 5;;
- : bool = true
# odd 8;;
- : bool = false

プログラミング in OCaml ~関数型プログラミングの基礎からGUI構築まで~ p.51より。再帰的に定義する。

# let rec euclid m n =
if m = n then m
else if m > n then euclid n m
else euclid (n - m) m
;;
val euclid : int -> int -> int = <fun>
# euclid 12 60;;
- : int = 12
# euclid 12 6;;
- : int = 6

基本的には m≦n のつもりで書いているけど，n – m と m の大小関係は決定できないので3行目を入れた。これで m と n の大小関係も気にしなくて済んでいる。