Haskell のWriter モナド (1) – Control.Monad.Writer を使う前に

最終的な結果だけでなく、中間結果も出力したい

例えば、次のような簡単な計算を行わせた場合、

(1 + 2) * 3 - 4

答えは `5’  となる。

関数 (演算) が適用されるそれぞれの過程の結果を考えると、

1 + 2 => 3

3 * 3 => 9

9 – 4 => 5

となる。このように最終的な結果だけではなく、計算途中の結果も表示したい場合にはどうすればいいのだろう？

 

let 式で中間結果を束縛

まず考えられる方法は、それぞれの中間結果を後で参照できるように let 式内で変数に束縛。結果をコンマ区切りで表示するなら、

main = do let a = 1 + 2
              b = a * 3
              c = b - 4
          print $ show a ++ "," ++ show b ++ "," ++ show c ++ ","

結果は、

"3,9,5,"

 

結果の型を (値, 出力する文字列) に変更

次に計算の方法を少し変えてみる。先ほどは計算の過程の結果を文字列で返したが、今度は

• 計算の結果
• 出力する文字列

の 2 つの部分に分ける。つまり、各計算の結果が以下のようにタプルで返されるように変更。

計算 => (値, 出力する文字列)

main = let (a, log1) = (x, show x) where x = (1 + 2)
           (b, log2) = (y, show y) where y = (a * 3)
           (c, log3) = (z, show z) where z = (b - 4) 
       in  print (c, log1 ++ "," ++ log2 ++ "," ++ log3 ++ ",")

これを実行すると、

(5,"3,9,5,")

 

これでは長くてみっともないので、出力関数 out を定義。

out x = (x, show x)

これを使うと、

main = let (a, log1) = out (1 + 2)
           (b, log2) = out (a * 3)
           (c, log3) = out (b - 4) 
       in  print (c, log1 ++ "," ++ log2 ++ "," ++ log3 ++ ",")

 

式の参照関係に表われるパターン

ここで let 式内の計算の参照関係について注目すると、下図のように「上の計算の結果」を「下の計算」が順々に参照していることがわかる。( let 式なので式の並び順は本質的に関係ない。)

これは State モナドについて考えたとき と同じパターン。全体の計算の連なりの中において、2 つの式の参照関係のみに注目。2 つの間の連なり方を考えると、式の「つなげ方」を共通の部品として取り出すことが可能。その「つなぎ」を利用して全体の連なりを再構成できる。

 

2 つの式の つなぎ方 を定義

では、2 つの式をつなげる関数 comb について考える。 ( Monad の >>= に相当。 Philip Wadler の Monads for functional programming の “2.9  Variation three, revisited: Output” を真似した。)

comb 関数に渡す引数を m, n とし、n が m の結果を参照すると考える。先ほどの例で言うと let 式において out 関数の結果を束縛する部分。

comb m n = let (a, log1) = m

計算 m の結果をタプル (a, log1) に束縛。 a が「計算の結果」で、log1 は「出力する文字列」に相当。

次に、上記の計算の結果 a を参照する計算 n の結果をタプル (b, log2) に束縛。

comb m n = let (a, log1) = m
               (b, log2) = n a

b は n a の「計算の結果」で、log2 は「出力する文字列」に相当。

最後に、先ほどの計算の結果 b と、計算 m による出力と (log1) と 計算 n による出力 (log2) を結合したものをタプルにつめて返す。

comb m n = let (a, log1) = m
               (b, log2) = n a
           in  (b, log1 ++ log2)

下図の具体例では、つなぎ を考えずに 3 つの計算を一気に行っているので つなぎ の定義と変数名が異なるが、最終的な結果 c と中間結果として出力したものを結合し、タプルに入れて返すことに相当する。

 

つなぎ を使ってみる

上記の comb 関数を使い、先ほどの計算を再定義する。

comb m n = let (a, log1) = m
               (b, log2) = n a
           in  (b, log1 ++ log2)

out x = (x, show x ++ ",")

main = print $ out (1 + 2)  `comb` \a ->
               out (a * 3)  `comb` \b ->
               out (b - 4)

( out 関数においてコンマを出力するように変更した。)

comb 関数を使うことにより、各々の計算の参照関係に気を使う必要がなくなった。どの式がどの結果に依存するかを明示しなくても、 comb 関数のつなぎ方によりその関係が成立する。

(上記 main 関数の定義において、括弧は省略しているが、無名関数は「できるだけ右へ拡張される」ように解析されることに注意。)

 

前の結果に関心のない つなぎ

ここで、一連の本質的な計算とは関わりのない、文字列を出力をするための関数 outStr を定義してみる。

outStr x = ((), x)

計算の内容に関わらないので、返されるタプルの第1要素は () 。これを使い次の計算を実行すると、

main = print $ outStr "begin: " `comb` \_ ->
               out (1 + 2)      `comb` \a ->
               out (a * 3)      `comb` \b ->
               out (b - 4)      `comb` \_->
               outStr " :end"

結果は、

((),"begin: 3,9,5, :end")

あらら… (@_@; 、肝心のタプルの第1要素が計算の結果でなく () になってしまった。 これは後で修正するとして後回し。先に comb 関数を使い、outStr 関数のような本質的な計算に関わらない関数をつなげるための関数を定義しおく。 (Monad の >> に相当)

comb_ m n = m `comb` \x -> n

これで上記を次のように書き換えることができる。

main = print $ outStr "begin: " `comb_`
               out (1 + 2)      `comb` \a ->
               out (a * 3)      `comb` \b ->
               out (b - 4)      `comb_`
               outStr " :end"

 

計算の対象 と 出力する内容を分離する

先ほどの問題、最後で返される値のタプルの第１要素が () となってしまうことに対して、次のように書いたとする。

main = print $ outStr "begin: " `comb_`
               out (1 + 2)      `comb` \a ->
               out (a * 3)      `comb` \b ->
               out (b - 4)      `comb` \c ->
               outStr " :end"   `comb_`
               out c

実行すると結果は、

(5,"begin: 3,9,5, :end5,")

結果は返ってきたけれど、最後に余分なものが出力されてしまった。 (+_+)

これは out 関数において、次の二つがごちゃ混ぜになっていることが原因。

• 本質的な計算の結果を返す
• 出力する内容を返す

また、上記の問題に加えて、本質的な計算の過程の一部を出力したいくないということにも対応できない。例えば、最初の 1+2 の結果を出力せずに計算を進めることは、このままではできない。 out 関数を使って計算を進め、同時に結果を出力しているからだ。

これを解決するために out 関数を変更する。これまでは出力する内容と伴に結果を返していたけれど、出力のみに特化。

out x = ((), show x ++ ",")

次に、出力は空だけれど、結果を返すことに特化した関数を定義。 (Monad の return に相当)

ret x = (x, "")

この二つを使って先ほどの関数を定義しなおすと、

main = print $ outStr "begin: " `comb_`
               ret (1 + 2)      `comb` \a -> 
               out a            `comb_`
               ret (a * 3)      `comb` \b ->
               out b            `comb_` 
               ret (b - 4)      `comb` \c ->
               out c            `comb_`
               outStr " :end"   `comb_`
               ret c

全体のソースコードはこちら。

 

命令型言語との比較

上記の定義は `comb` に目をつむれば、以下のように Python で定義したときとよく似ている。

def main():
    a = 1 + 2
    print a
    b = a * 3
    print b
    c = b - 4
    print c
    return c

print main()

これを見ると、Python で「前に定義した変数を参照する」ことは、Haskell において「内側の関数 (無名関数) の中から外側の引数を参照する」ことに相当することがわかる。

 

参考文献

• Monads for functional programming
  • 2.4 Variation three: Output
  • 2.9 Variation three, revisited: Output

簡単中華風おにぎりの作り方

朝、おにぎりを作ろうと思ったら、昔買った

花椒塩  (ホワジャオイエン)

が残ってたので、普通の塩の代わりに手の平に塗ってニギニギ。

ホワジャオイエン【花椒塩】の意味 国語辞典 - goo辞書 によると、

中国の調味料の一。塩と山椒(さんしよう)の実をいっしょに煎(い)り、細かく挽(ひ)いたもの。揚げ物などに添える。

山椒好きにはたまらない調味料。 ^^ ちょっと舌がビリっとする。

普通の塩を少量混ぜた方が味に締まりがでたかも。こうやって他の調味料でも適当に手の平に塗れば、それ風のおにぎりのできあがり。

Meadow の dired でよく使うキー操作

良く使う基本操作

Meadow で必ずお世話になるのは dired 。

M-x dired

で起動し、表示したいディレクトリを指定。

 

日付で並び換え

ディレクトリが開かれたら、まずは日付で並び換え

s

の後、目的のファイルを探す。

C-s または C-r でインクリメンタルに目的の場所へ移動し Enter 。

 

ヘルプ

操作方法を忘れたら、

?

これだけは忘れられない。

 

すぐに忘れる表示の更新 g

dired でディレクトリを開いた後、新たに作成したファイルは表示されない。はじめこの仕様に戸惑った。 (+_+) 表示を更新するには GNU Emacsマニュアル: ディレクトリエディタdired によると、

g

これすぐに忘れる。 (+_+) なんで `g’ なのかな？更新のイメージとキーを結びつけられない。

 

ディレクトリの作成も dired で +

Meadow/Emacs memo: ディレクトリ表示 ― dired など の基本的な操作を見たら、

+

でディレクトリを作成できたことにはじめて気がついた。いつも make-directory で作ってた。 ^^;

 

Explorer との連携をするための設定

いつか設定しようと思っていたエクスプローラとの連携。重い腰をあげ、Meadow/Emacs memo: ディレクトリ表示 ― dired など の「エクスプローラを起動する設定」を .emacs に追加。

これで dired で

E

により dired で開いていたディレクトリがエクスプローラで表示される。

編集中のファイルを開いている状態でも M-x explorer でそのファイルがあるディレクトリが開かれる。

快適～ ^^

Access の VBA でスタックトレースを表示

メニューより 「表示 > ツールバー > デバッグ」にチェックを入れる。

VBA のコードを実行する前にブレークポイントを設置。実行して停止したところで、ツールバーの「呼び出し履歴」のアイコンをクリック。

ショートカットキーは、Ctrl + L 。表示メニューにある。

Access の VBA で複数行をコメントアウト

メニューより 「表示 > ツールバー > 編集」にチェックを入れる。

コードを複数行選択し、ツールバーのコメントブロックのアイコンをクリック。

ウィンドウを前面で固定 - 「最前面でポーズ」

最前面でポーズ
via kwout

Windows xp では、特定のウィンドウを前面に固定するためのユーティリティとして「貼り付け」を利用していた。 Vista でも愛用しようと思っていたけれど、なぜか自分の環境では起動してくれなかったり、動作がぎこちなかったりと残念ながら使用を諦めざる終えず。。 (+_+)

代わりになるものはないかと探したら、最前面表示を［Pause］キーでON/OFF「最前面でポーズ」 が良さげ。とにかくシンプルで、操作が Pause キー 一発でウィンドウを前面に固定というのがいい。 ^^

ただし、Pause キーを押すと

というダイアログが表示されるが OK ボタンを押す必要はなく、1, 2 秒待っていると自動的に消える。最初、OK ボタンを押さなければならないと勘違いし、右手の薬指で Pause キーを押し、キーボードを目視せずに親指で Enter キーを押せるように練習してしまった。 ^^;

「貼り付け」のようにウィンドウをピンで止めるというようなギミックがないので、どれが前面にあるウィンドウなのか一目ではわからない。しかし、それほど多用するわけではないので、これで必要にして十分かな。

被演算子の一つを返す AND, OR - デフォルト値の設定

if と真偽値 の続き。

 

Python のブール演算における例外的なこと

前回見たように、Python では if 文においてたくさんの値が `偽’ と見なされる。ただし、 ドキュメント の最後には次のように書かれている。

ブール値の結果を返す演算および組み込み関数は、特に注釈のない限り常に偽値として 0 またはFalse を返し、真値として 1 または True を返します (重要な例外: ブール演算 "or" および "and" は常に被演算子の中の一つを返します)。

(2.3.1 真値テスト より、太字は引用者による。もしくは 6. Built-in Types — Python v2.6.4 documentation を参照)

例えば、組み込み関数である all, any なら、

l = range(10,100)
print all(map(lambda x: x >= 10, l)) #=> True
print any(map(lambda x: x < 10, l))  #=> False

というようにブール値を返す。では、「重要な例外」と書かれている or, and は、どういう意味で重要なのだろう？なぜ素直にブール値を返さないのか？

ちなみにこれが Java なら、

条件AND式の型は，常に boolean とする。…

条件OR式の型は，常に boolean とする。

(Java言語規定 式 より)

のように必ずブール値を返す。

 

if 文における and, or

偽 と解釈される値の場合

普通、and 演算子は次のように if  と組み合わせて使用される。

x = "hoge"; y = "piyo"

if x != "" and y != "":
    print x, y

上記を実行すると、”hoge piyo” と出力。

ところで、Python の文字列は、if の検査において、空文字が 偽 でそれ以外は 真 として扱われた。よって、先ほどの if による空文字かどうかの検査の部分、

if x != "" and y != "":

を次のように書換えることができる。

if x and y:

この一見すると奇妙で意味を汲みにくい書き方を素直に読むなら、

もし x かつ y ならば…

となり、最初に書いた

もし x が空文字であり、かつ、 y も空文字であるならば…

に比べると曖昧に見える。

 

評価のされ方を確認

上記のように 偽 の値であることを想定して書いたときの、if 文と and, or 演算子における値の評価を確認してみることに。最初はちょっと奇妙に思えるが、以下のように文字列に and , or 演算子を適用。

print "hoge" and "piyo" and "fuga"  #=> “fuga”
print "hoge" or  "piyo" or  "fuga"  #=> “hoge”

最初見たドキュメントの通り、被演算子の中の一つが返されているのがわかる。このルールは、5.10 ブール演算 (boolean operation) によると、

式 x and y は、まず x を評価します; x が偽なら、x の値を返します; それ以外の場合には、 y の値を評価し、その結果を返します。

式 x or y は、まず x を評価します; x が真なら、x の値を返します; それ以外の場合には、 y の値を評価し、その結果を返します。

(and も not も、返す値を 0 や 1 に制限するのではなく、最後に評価した引数の値を返すので注意してください。

(太字は引用者による)

これに従うと、

if x and y:

の例では、次のような評価の流れとなる。

1. and 演算の評価
   • x は空文字でないので真
   • y は空文字でないので真
   • y の値を返す
2. if の評価
   • and 演算子の結果は空文字でないので真

 

JavaScript で || によってデフォルト値を設定する方法

ところで、Python に負けず劣らず 偽 と解釈される値が多い JavaScript では、Python の or に相当するのは || 。JavaScript: The Good Parts (pp.24-25) には、この || 演算子を使った「デフォルト値」を設定する方法が書かれている。

例えば、`名前と年齢’ を対にしたハッシュを定義し、ハッシュの要素ではないものを参照しようとしたとする。

var persons = {"Tarou" : 10, "Jirou" : 20, "Hanako" : 30};
var age = persons["Saburou"] || 0;

|| 0 と書くことにより、 age には 0 が代入される。先ほどの Python の or と同じルールを思い出しながら評価の流れを考えると、

1. persons[“Saburou”] に相当するものがないので undefined が返される。
2. undefined は 偽 と見なされる。
3. || 演算子のルールに従い、|| の右辺の 0 が評価され、0 が返される。

 

Python でも or でデフォルト値を設定

Python でも同じようにして、デフォルト値を設定できる。

a = 0
print a or 100 #=> 100

ん～ (@_@; 一見意味がわかりずらい。。

このようにデフォルト値の設定を or 演算子でできるのは、

1. 偽 と見なされる値がいくつかあり、
2. or の結果がブール値ではなく評価した値そのものを返している

ことによる。

 

ところで、どうしても短く書きたいなら、条件式 を使った方が意図が明確になる。

print a if a else 100

いや、正直言うとこの書き方も好きではない。

print a if a != 0 else 100

頭が堅いのかな？こうでないと今一安心できない ^^;

 

Ruby でも || でデフォルト値を設定

Ruby の場合は、nil が 偽 と見なされるので、次のように書ける。

a = nil
p a || 100 #=> 100

しかし、Python や JavaScript の癖が抜けずに、

a = 0
p a || 100 #=> 0

と書くと、意図したものと違う結果になるので注意。

 

ある一つの機能は、一つのことだけのために限ってほしい

結局、言語によって 偽 と見なす値が異なることと、and , or のような演算子がブール値でなく、評価した値のいずれかを返すという仕様が、自分のようなすぐに忘れる脳みそにとってはどうしても好きになれない。 (+_+) そもそもブール演算に用いるものを、デフォルト値の設定に使うという発想が自分はダメ。道具は用途を限り、それにのみ使えるようにしておかないと、脳みその容量が少ないので混乱してしまう。 一時慣れたとしても、しばらく使ってないと忘れる自信ならたっぷりある。(o_ _)ｏ~†

加えて、演算子が場合に応じて異なる型の値を返すということも居心地が悪い。 (+_+)  「返すならブール型だけで勘弁してください」と言いたい気分。異なる値を返すなら、特定のインターフェイスを実装している型、もしくは、Haskell で言うなら同じ型クラスのインスタンスのみに限定してほしい。以前、少しの手間を惜しみ、ある関数で異る型の値を返すようにしたことがある。一時的の`つもり’で書いたのだけれど、それを忘れ、後になって見つけづらいバグになってしまった。 もちろん、「ちゃんとテストコード書いておけよ」という話なんだけれど。

とにかく、ポカミスを連発し、ミスをしてないという思い込み、エラーの発見が苦手な自分のようなタイプにとって、例外的なことは本能的に避けたくなる。多分、そうでない人にとっては、便利さとのトレードオフが考慮された例外的な事柄は便利だと感じるのだろうなぁ。

 

追記 (2010.1.16) : Google Python スタイルガイド では、True/False の評価について次のように書かれている。

可能な場合は、非明示的な false を利用する。…

利点:

Python のブール値を使うと、可読性が高まり、エラーを防ぐことができます。さらにほとんどの場合で、これは高速です。

うーん、可読性高まるのかなぁ～ (@_@; 

 

Haskell で似た関数を定義する

Haskell で同じようにデフォルト値を設定しようと、次のように書くと、

a = 0
b = a || 100

|| が適用する型が一致しないので、当然エラーとなる。どうしても上記のようなデフォルト値を設定する演算子が使いたいのなら、|| とは別に定義する。

デフォルト値を設定する演算子を ||| で定義するなら、

(|||) x d = if x == 0 then d else x

となる。これを使って、

a = 0
b = a ||| 100  -- b は 100

ただし、これでは数値にしか使えない。

 

JavaScript の or に相当する ||| 関数

前回、Haskell で Python のように型ごとに if の解釈を変えるためにオーバーロード を利用した。コードは以下の通り。

class Boolean b where
    isTrue :: b -> Bool

instance Boolean Bool where
    isTrue True  = True
    isTrue False = False

instance Boolean Integer where
    isTrue 0 = False
    isTrue _ = True

instance Boolean [a] where
    isTrue [] = False
    isTrue _  = True

if' x e1 e2 = if isTrue x then e1 else e2

それぞれの型でオーバーロードした if’ 関数は 型クラス Boolean のインスタンスに適用できる。これを元に if’ を定義したときと同じように考える。

(|||) e1 e2 = if isTrue e1 then e1 else e2

… あれ？ ||| と if’ の定義は形がよく似ている。こんな冗長なコードを書いていたらだめか。。

if’ を使って書き直すと、

(|||) e1 e2 = if' e1 e1 e2

引数を省略して以下のように書けるけれど、これだと意図がわかりずらいかな。 (@_@;

(|||) e1 = if' e1 e1

試してみる。

*Main> 0 ||| 100
100
*Main> 1 ||| 100
1
*Main> [] ||| [1,2,3]
[1,2,3]
*Main> [1,2] ||| [1,2,3]
[1,2]
*Main> "" ||| "hoge"
"hoge"
*Main> "piyo" ||| "piyo"
"piyo"

 

ついでに Python の and に相当する &&& も定義する。

(&&&) e1 e2 = if' e1 e2 e1

if’ , &&&, ||| を組み合わせて試すと、

*Main> if' ("hoge" &&& "piyo" &&& "fuga") 1 0
1
*Main> if' ("hoge" &&& "piyo" &&& "" &&& "fuga") 1 0
0
*Main> if' (1 &&& 2 &&& 3) 1 0
1
*Main> if' (1 &&& 2 &&& 0 &&& 3) 1 0
0
*Main> if' ("hoge" ||| "" ||| "piyo") 1 0
1
*Main> if' ("" ||| "") 1 0
0
*Main> if' (1 ||| 0 ||| 2) 1 0
1
*Main> if' (0 ||| 0) 1 0
0

全体のコードはこちら。

 

Ruby でも同様に

Haskell では if を関数として定義し、型ごとにオーバーロードし、and, or に相当する関数を定義した。同じように Python でもできないかと考えたが、Python は組込クラスに手を出せない。 (+_+) それに対して、Ruby は組込クラスにメソッドを追加することができる。 (cf. リストと文字列を透過的に扱うには ) そこで、Ruby で同じように書けるか試してみることに。

Ruby では偽と解釈される値は false 以外に nil だけだった。これを Python と同じように Array, String, Integer でもそれぞれ偽と解釈される値を想定し、 if をメソッドとし実装。それに伴い and, or メソッドも追加し、or メソッドでデフォルトの値を設定できるようにする。

作成するモジュールとクラスは以下の通り。

Control モジュールで if メソッドを定義。これを使って、Bool モジュールで and, or メソッドを実装。イテレータを実装するときのようにテンプレートメソッドパターンを使って、各々のクラスで値による真偽のルールを記述する。

 

実装

まずは Control と Bool モジュールから。 Control モジュールの if メソッドは、真の値のときに評価されるブロック e1 と、偽の値のときに評価されるブロック e2 を受けとり、if メソッドが呼出されたオブジェクトの値に応じて e1 もしくは e2 を返す。 if_ メソッドは、その場で評価に応じてブロックを実行するようにした。 isTrue? と呼出しているメソッドは、このモジュールをインクルードする組込クラスで定義する。

Bool モジュールは Control モジュールで定義した if メソッドを使って and, or メソッドを定義。

module Control
  def if(e1, e2)
     if self.isTrue? then e1 else e2 end
  end
  def if_(e1, e2)
    self.if(e1, e2).call
  end  
end

module Bool
  include Control
  def and(other)
    self.if(other, self)
  end
  def or(other)
    self.if(self, other)
  end
end

後は、組込クラスで isTrue? メソッドを実装し、真偽と解釈される値の範囲を設定。

class TrueClass
  include Bool
  def isTrue?
    if self == true then true else false end
  end
end

class FalseClass
  include Bool
  def isTrue?
    if self != false then true else false end
  end
end

class NilClass
  include Bool
  def isTrue?
    if self != nil then true else false end
  end
end

class String
  include Bool
  def isTrue?
    if self != "" then true else false end
  end
end

class Integer
  include Bool
  def isTrue?
    if self != 0 then true else false end
  end
end

class Array
  include Bool
  def isTrue?
    if not self.empty? then true else false end
  end
end

まずは if と if_  メソッドを試してみる。変数 x, y に false, nil, "", 0, [] に入れて同じ動作をするか確認。if メソッドにおいて、オブジェクトの値によって設定した真偽が決定し、実行するブロックが決まる。

x = 0
y = 1

x.if(proc{ p "T" },
     proc{ p "F"}).call

x.if_(proc{ 
        p "T" 
        y.if_(proc{ p "TT" }, 
              proc{ p "FF" })
      },
      proc{ 
        p "F"
        y.if_(proc{ p "FT"}, 
              proc{ p "FF"})
      })

次に and, or を試す。

p true.and true                 #=> true          p 1.and 2.and 3                 #=> 3
p "hoge".and "piyo".and "fuga"  #=> “fuga”

p "hoge".or "piyo".or "fuga"    #=> “hoge”
p "".or "hoge"                  #=> “hoge”

ダックタイピングな Ruby なので、こんなのも書けてしまうか。(+_+)

p false.or 0.or "".or [].or 1000

もう何がなんだかわからなくなってきた。まぁ、これが書けたからどうというわけでもなく、あくまでもこんな風にも記述できるという実験ということで。 ^^;

コード全体はこちら。

 

Scheme の and , or はどうなの？

そういえば、Scheme でも見かけは同じような動作をする。

(and 1 2 3)                  ;=> 3
(and "hoge" "piyo" "fuga")   ;=> “fuga”
(or 1 2 3)                   ;=> 1
(or "hoge" "piyo" "fuga")    ;=> “hoge”

Structure and Interpretation of Computer Programs によると、

(and <e₁> ... <e_n>)

The interpreter evaluates the expressions <e> one at a time, in left-to-right order. If any <e> evaluates to false, the value of the and expression is false, and the rest of the <e>'s are not evaluated. If all <e>'s evaluate to true values, the value of the and expression is the value of the last one.

(or <e₁> ... <e_n>)

The interpreter evaluates the expressions <e> one at a time, in left-to-right order. If any <e> evaluates to a true value, that value is returned as the value of the or expression, and the rest of the <e>'s are not evaluated. If all <e>'s evaluate to false, the value of the or expression is false.

(太字は引用者による)

こういった評価の方法をするものを special form と言うらしいが、

Each special form has its own evaluation rule. …

the evaluation rule for expressions can be described by a simple general rule together with specialized rules for a small number of special forms. …

Special syntactic forms that are simply convenient alternative surface structures for things that can be written in more uniform ways are sometimes called syntactic sugar,

(Structure and Interpretation of Computer Programs より)

Scheme 入門 15. 構文の定義 によると、

マクロとは式の変換です。

…

or, and はマクロで、以下のように再帰的に定義されています。マクロ定義も再帰的に定義できるので、かなり複雑な構文を定義することができます。

Scheme はまだ全然わからないので、これは保留。ただし、式の評価方法という観点から、他の言語とは違うメタレベルを導入して定義してあるような気が。「ブール型だからこうだよ」というように型の視点からではなく。

 

参考

• Scheme/マクロ - Co-Coa Wiki

Access で参照整合性を設定したフィールドを含むレコードの入力をキャンセルする

参照整合性の設定

例えば、家計簿のようなものを作ろうと思い、以下のようなリレーションシップを持ったテーブルを作成した。ここでは、使った金額の 「支払い」 において、誰がどこへ支払い、その明細を管理したいもとする。 (抜粋)

「支払」 テーブルの 「支払先ID」 フィールドは 「組織」 テーブルの ID を外部キーとして持ち、「支払人ID」 は 「支払人」 テーブルの ID を外部キーとして持ち、参照整合性を設定。

 

フォームの作成

次に、「支払」 テーブルを元にフォームを作成し、動作の確認をする。

ここで、「支払先」 または 「支払人」 に値を入力をした後、フォームのデザインに戻りたいとする。もし、「支払先」 と 「支払人」 フィールドに参照整合性制約に抵触しない値を入力した場合、その値がデータベースに保存された後、フォームデザインの画面に切り替わる。しかし、参照整合性制約に抵触した値を入力した場合、フォームデザインに戻ろうと思っても、

バリアント型でない変数に Null 値を代入しようとしました。

とエラーダイアログが表示される。入力を取消したいと思い、入力した値を BackSpace キー消しても同じダイアログが表示。

 

Esc キーで入力のキャンセル

メニュー下の「レコードの削除」ボタンを押しても、全てのフィールドに正当な値が入力されてないとダメ。仕方がないので、とりあえず正当な値を入力しておき、その後レコードの削除するということで対応できる。しかし、これでは面倒。 (+_+)

[ACC97]: Access データベース内の関連テーブル内のレコードを編集します。 によると、

注: 入力ミスを修正、BackSpace キーを押します。 現在のフィールドに加えた変更をキャンセルするには、Esc キーを押します。 レコード全体に加えた変更をキャンセル、Esc キーを押します

(太字は引用者による)

あ～、Esc キーだったのか。基本的な操作すらわかってないな。。 ^^;

画面の拡大に「快速ズーム」

Magic Mouse のズーム機能が欲しい

老眼ではないけれど、入力フィールドの文字ポイントが小さいとストレスがたまる。 (+_+) Ctrl + U のショートカットキーでシステム標準の拡大鏡の使い勝手も今一。

下の動画で紹介されている Mac のズーム機能に似たものはないかな？

 

QZoom

Vector：QZoom「快速ズームソフト」 によると、

QZoomとは、WindowsでMac OS Xのズーム機能を実現するためのソフトです。…

もちろんマウススクロールでの拡大・縮小にも対応してます。

おぉ～、これはいい ^^ 直観的で、素早い操作が一番。

 

ショートカットキーの設定

起動すると、タスクトレイに常駐。ここら設定画面を呼出し、キャンセル操作のショートカットキーだけ変更した。なぜなら、他のアプリで Esc キーに操作が割り当てられていた場合、QZoom の設定が優先的に扱われてしまったため。

 

Vista で画面がチラつくとき

Windows Vista において、Skype でビデオチャットをしているときに管理者権限が必要な操作をすると、なぜか Aero 機能が無効になる。このとき、QZoom を利用すると画面がチラついて操作がもたつく。この場合は Skype を一度終了させると Aero 機能が再度有効になるので、その後に Qzoom を起動しなおす。これは他の拡大するためのアプリでも同様だった。

if と真偽値

Java の if 文での検査は真偽値のみ

最初に馴染んだ言語が Java だったので、「if 文での検査で使えるのは当然 true または false でしょ」という感覚が染み込んでいる。例えば、Java で

if (0){
 ...
}

をコンパイルしようとすると、

Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - 互換性のない型
  期待値: boolean
  検出値:    int

というエラーが表示される。

Java言語規定 ブロック及び文 の 「14.8 if 文」によると、

if ( Expression ) Statement

… 式(Expression) は，論理型をもたなければならない。そうでなければ，コンパイル時エラーが発生する。

(太字は引用者による)

という仕様であるため。

 

C 言語 の if 文での検査は 0 が 偽

しかし、C 言語では上記のコードでもコンパイルが通る。なぜなら、初級C言語Q&A(5) によると、

Ｑ 【真偽値】

他の言語には真偽の値を表現するための型が用意されているものがあるが、なぜC言語には用意されていないのか。

Ａ

… 最も大きな理由は、それがなくても実用上差し支えないからでしょう。実際、1という値を真、0という値を偽であることにすれば、整数型を使って真偽を表現することが可能ですから。

この `0’  を偽 と見なすのは最初違和感があった。。 (@_@;

数値の比較をしてみると、

1 == 1

で 1 が返り、

1 < 1

で 0 が返る。

この仕様だと、自分でブール型を用意しなければ、真偽値を返すことを意図した関数と、数値を返す関数をコンパイラが区別できない。 (+_+)

ただし、プログラミング言語 C の新機能 によると C99 で、

今度の C 言語では新しい整数型 _Bool 型を導入することでその問題を解決します。この型は 0 と 1 が入れば十分な大きさとされており、必ずしも int 型と同じサイズであるとは限りません。

となり、型的にはスッキリとする。

 

Python, Ruby の真偽テスト

Python はたくさんの値が 偽 と解釈される

Python は 2.3.1 真値テスト で述べられているように、たくさんの型の値が条件文で 偽 として扱われる。例えば、リストと文字列の上位にシーケンス型があり、空文字・空リスト

”” , []

は 偽 。(これにより、if の検査で リストと文字列を透過的に扱う ことができる。)

これを「真偽テスト」というのは言い過ぎでないの？ってくらい多い。 ^^; バグを誘発しそうで怖い。。

 

Ruby は false に加えて nil のみ

Ruby はこれに対して、false に加え nil が偽と判定されるのみ。 Python 比べたらスッキリしている。ただし、Java で

if (null) {

なんて書いたらエラーになるので、これもやや違和感を覚えた。

しかし、Ruby で上記のような書き方は実際に多用されているのだろうか？いや、そもそも多用されていたら Null Object パターン に持ちこむか。 JavaScript では DOM の操作でよく見るけれど。

 

JavaScript の falsy

JavaScript の場合は、

以下に、条件式が falsy, つまり偽と評価される値を示す。

• false
• null
• undefined
• 空文字
• 数値の 0
• 数値の NaN

(JavaScript: The Good Parts ―「良いパーツ」によるベストプラクティス, p.14 より)

false ならぬ falsy という単語で述べられているように、Python に負けず劣らず 偽 と解釈される値が多い。 (@_@;

(ちなみに、最初 JavaScript 見て嫌だなと思ったのがこの真偽テストに絡んでいる。「え？この if で何を確認してるの？」と、馴染まない内はイラつかされるオブジェクトの存否チェック、そしてネストネストでズラズラズラ…。あ～、どこに本質的な仕事が書かれているんだろう？とコードの森で迷い。。)

総じて Script 系の言語は、さっと書くという利便性のために、「どこまでを if の検査で 偽 と見なすか」について設計思想が違うということかな。

 

型とは

話変わって、「型」とは何だっただろうか？ 以前 にも引用したが 「データベース実践講義」 の 「2.3 型とは」 (p34) によると、

型とはいったい何か。基本的には、値の名前付き有限集合である。…

すべての型が、その型の値もしくは変数に作用する演算子の連想集合を持つ …

とのこと。

ある値の集合が型であり、その型に属する値に対して適用できる関数や操作が定義されるという見方。

 

Java のプリミティブ型としての boolean

Java に戻り、真偽値について確認してみると、

型 boolean は，リテラル true 及び false (3.10.3) で示す二つの可能な値をもつ論理的な量を表す。

(Java言語規定 型，値及び変数 の 4.2.5 boolean型 及び boolean値 より)

値の集合が定義され、適用できる論理演算子が言語仕様として示されている。ただし、プリミティブ型である true, false が Java 言語で書ける枠内で、型に属する値として定義されているわけでない。 &&, || のような論理演算子についても同様。 Java を使う側は概念的イメージとして boolean 型を意識し、それに即してコードを書くとコンパイラが型をチェックしてくれる。

 

C の真偽は数値

前述の通り、C言語では C99 より前は真偽値に対応する型は用意されてなかった。真偽値として見なしたい値は数値なので、数値に対する演算子が適用できてしまう。 boolean 型として扱うとプログラマが意識したところで、コンパイラにとっては区別不能。

 

Ruby の TrueClass , FalseClass

組み込みクラス／モジュール／例外クラス
- Rubyリファレンスマニュアル via kwout

Ruby では、

Ruby の面白いのは、Boolean というクラスは無く、 true と false はそれぞれ TrueClass と FalseClass というクラスのインスタンスである。

(「各言語におけるtrue/falseまとめ - 床のトルストイ、ゲイとするとのこと」 より)

これ読むまで、てっきり Boolean というクラスがあると思っていた。 ^^;

確認のため TrueClass のスーパークラスとインクルードしているモジュールを表示させてみると、

p TrueClass.ancestors   #=> [TrueClass, Object, Kernel, BasicObject]

となり、true と false だけをまとめる型は定義されていない。つまり、Ruby の言語の枠内でブール型というものが独立して明示されていない。だから、 and や or のようなものが、

再定義できない演算子(制御構造)

(演算子式 - Rubyリファレンスマニュアル より)

として、何となく微妙な感じの位置付けになっているのかな？

 

Python の真偽は数値のサブタイプ

3.2 標準型の階層 via kwout

ついでなので Python についても調べたら、 3.2 標準型の階層 に

ブール型 (boolean)

… ブール型は整数のサブタイプで、ほとんどの演算コンテキストにおいてブール型値はそれぞれ 0 または 1 のように振舞います。ただし、文字列に変換されたときのみ、それぞれ文字列 "False" および "True" が返されます。

うげぇ～ (@_@; 整数のサブタイプだったとは。。

ということは、次の計算がエラーとならない。

print True + True + False #=> 2
print True * 10           #=> 10

上記のような計算を成立させることの積極的な意味は何だろう？？？

ともあれ、`0’ が if 文において 偽 と解釈される理由はこういう設計に依るのかも。どうしても ごちゃごちゃしているという感が否めない。 (+_+)

PEP 285 -- Adding a bool type では次のように述べられている。、

There's a small but vocal minority that would prefer to see
"textbook" bools that don't support arithmetic operations at
all, but most reviewers agree with me that bools should always
allow arithmetic operations.

…

6) Should bool inherit from int?

=> Yes.

ということで、この設計はこのままずっと行くみたい。

 

Haskell の Bool 型

base-4.2.0.0: Basic libraries
via kwout

これに比べて Haskell はシンプル。 Data.Bool に、型とその値の集合が次のように定義されており、

data Bool  = False  | True

Bool 型に適用できる関数が示されている。

(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not  :: Bool -> Bool

そして、条件式 である if – then – else の検査では Bool 型しか許されない。 case 式と同等なものとして以下のことが成り立つようになっている。

if e ₁ then e ₂ else e ₃ = case e ₁ of { True -> e ₂ ; False -> e ₃ }

( The Haskell 98 Report: Expressions  3.6 Conditionals より)

先ほどの 「型とは何か？」 という視点から見ると、なんてスッキリとしているんだろう。 ^^ 

… とは言ったものの、最初は「何でこんなものが普通の関数と同じように定義されているの？」 と思ったけれど。 ^^;

 

型ごとに if の解釈を変えたいならオーバーロードで

もし、Python のように Bool 型に加え、空リスト、空文字、0 で False としたいなら、if-then-else とは異なる if’ 関数を定義し、それぞれの型でオーバーロードするのがいいかも。

if を関数で定義するとは、表計算で、

if (条件, 真の場合, 偽の場合)

のように使うときのイメージで。 (cf. Data.Bool.HT の if’ 関数)

 

まずは、値に適用したら Bool 型を返す isTrue 関数を持つ、型クラス Boolean を定義。

class Boolean b where
    isTrue :: b -> Bool

Bool, Integer, [a] 型を、型クラス Boolean のインスタンスにして、それぞれの型に応じた True , False を定義。

instance Boolean Bool where
    isTrue True  = True
    isTrue False = False

instance Boolean Integer where
    isTrue 0 = False
    isTrue _ = True

instance Boolean [a] where
    isTrue [] = False
    isTrue _  = True

これを使って if’ 関数を定義。 x の値が 真 と見なした値の場合 e1 が評価され、偽 の場合 e2 が評価される。

if' x e1 e2 = if isTrue x then e1 else e2

 

試しに使ってみる。数値の場合、

*Main> if' 0 "hoge" "piyo"
"piyo"
*Main> if' 1 "hoge" "piyo"
"hoge"

リストの場合、

*Main> if' [] "hoge" "piyo"
"piyo"
*Main> if' [1,2,3] "hoge" "piyo"
"hoge"
*Main> 

リストで定義しているので、文字列の場合でもちゃんと動作する。

*Main> if' "" "hoge" "piyo"
"piyo"
*Main> if' "test" "hoge" "piyo"
"hoge"

 

if’ を適用できる型を忘れてしまっても :i で調べられる

上記の if’ 関数の型を調べると、

*Main> :i if'
if' :: (Boolean b) => b -> t -> t -> t

もし、if’ 関数は何の型を 真・偽 と見なすか忘れてしまっても、 :i で 型クラス Boolean のインスタンスを表示できる。

*Main> :i Boolean
class Boolean b where t :: b -> Bool
instance Boolean Bool
instance Boolean Integer
instance Boolean [a]

 

if の解釈は所与のものであってほしくない

上記のように if – then – else は ブール型の検査のみで、それ以外の値を 真・偽 と見なして評価したいなら別腹で定義する方が好み。これなら評価の方法を自分の好きなように任意の型で定義できる。

Python でも同じように、クラスごとに真偽テストの挙動をカスタマイズできる。

以下の値は偽であると見なされます …

__nonzero__() または __len__() メソッドが定義されているようなユーザ定義クラスのインスタンスで、それらのメソッドが整数値ゼロまたは bool 値の False を返すとき

(2.3.1 真値テスト より)

(このメソッド名を見ても、あくまでも bool は int のサブタイプだぞ、覚えておけよ ! という気迫 を感じる。 ^^;)

結局のところ、if で型ごとに 真偽 が異なることは、オーバーロードのことだと解釈できる。これを言語が所与のものしてしまうと、「一体それはどういう訳なんだろう？」と疑問がわき、頭の中がごちゃごちゃになり、すぐに忘れるこの脳みそ。 (+_+)

 

Scheme

最近ちょっといじりはじめた Scheme ではどうなっているか調べたら、Structure and Interpretation of Computer Programs によると、

¹⁷ ``Interpreted as either true or false'' means this: In Scheme, there are two distinguished values that are denoted by the constants #t and #f . When the interpreter checks a predicate's value, it interprets #f as false. Any other value is treated as true. (Thus, providing #t is logically unnecessary, but it is convenient.)

真偽は #t, #f の定数として定義され、#f のみが偽で、それ以外は真。 #t は実質的にはいらないと。

うーーーん (@_@; 違和感を感じるなぁ～。

 

関連記事

• 続き : 被演算子の一つを返す AND, OR - デフォルト値の設定

 

参考サイト

• 各言語におけるtrue/falseまとめ - 床のトルストイ、ゲイとするとのこと
• 404 Blog Not Found:js/perl/python/ruby/scheme - 真偽のほどはいかに
• Conditional (programming) - Wikipedia
• Boolean data type - Wikipedia
• ブーリアン型 – Wikipedia
• Functions and Function Definitions

DrScheme で Emacs のキーバインディング

関数型言語 界隈の話を読んでいると、必ずどこかで顔を出すのが「継続」と「マクロ」。Haskell でも Continuation モナド を理解するには、Scheme を触っておくのが手っ取り早いのかな。 Lisp 系の言語はいじったことがないので、これを機にやってみようかな。以前から SICP は読んでおかねばと思いつつ、ずっと放置していた。 ^^;

しかし、いきなり SICP は無理なので、

• もうひとつの Scheme 入門

で勉強しませう。

 

DrScheme でお手軽に試す

上記サイトで紹介されていた処理系は、

• PLT Scheme

Scheme 入門 1. Scheme 処理系のインストール によると、

DrScheme を利用する場合は MzScheme も同時にインストールされます。そのため、MzScheme を単独でインストールする必要はありません。実は、MzScheme は PLT-Scheme という処理系のエンジン部分で、DrScheme は PLT-Scheme のフロントエンドです

(太字は引用者による)

Emacs から使う方法も説明がされていたけれど、お手軽に GUI の環境で DrScheme を試すことに。

 

Emacs のキーバインディング

DrScheme のデフォルトのキー操作では思うように動かせない。 (+_+) Emacs と同じキー操作にできないかと調べたら、

If you are most familiar with Emacs-style key bindings, you should uncheck the Enable keybindings in menus preference.

(3.3 Keyboard Shortcuts より)

メニューより、「Edit > Preferences… > Editing > General」の Enable keybindings in menus のチェックをはずす。

これで快適～ ^^

 

実行と編集

Emacs で Haskell のコードを実行するときは C-c C-l 。C-x o で元のソースコードに戻って編集ということを繰り返す。 DrScheme では、

• F5 で実行
• F6 でエディタに戻る

括弧単位でカーソルを移動するには、

M-C-f : move forward one S-expression

M-C-b : move backward one S-expression

(3.3 Keyboard Shortcuts より)

ただし、

Under Windows and Mac OS X, Meta is only available through the Escape key.

(同上より)

メタキーは Alt ではなく、Escape を押さないといけないようなので、慣れるまで面倒に感じる。素直に Emacs で Scheme を使えるようにした方がいいかも… (+_+)