Real world haskell に浮気してて忘れてた

http://book.realworldhaskell.org/read/index.html

３ヶ月放置だったのね、しまった・・

このまま放置すると後味悪いので、少しづつでも進めよう。

でも同じ関数型言語でもLisp(Scheme)とhaskell違いがあっても面白いね

やっぱ一番の差異は "型" の存在かな？

型を安全で便利と思うか、俺様にはそんな安全装置不要だぜガンガンいくぜ、と思うかによってメリットにもなるし、デメリットにもなるし、オブジェクト指向でいうRubyとJava/C#の違いとか？

でもhaskellは型推論があるから省略もできるし、型からのパターンマッチがずいぶん便利だし、そういう意味ではhaskellの型は一歩リードだよなぁ

あとhaskellの方が参照透明性を大事にしてて頑固だよね、なんてったって純粋関数型言語だもんね。英語で言うと purely functional programming language で、名前にpureが付くなんて！頑固だなー

非決定性プログラムの例が山盛り。

が、実際に実行できないといまいち実感が湧かない、ということで4.3.3 で処理系を実装してから読む。

4.2の遅延評価に続いて、Scheme処理系に非決定性計算を組み込む。

二つの整数のリストから素数の組み合わせを探す時、通常の計算だとリストの組み合わせを全て作って、素数のペアを抜き出す。

遅延リストの場合、リストの組み合わせを最初に作らない（評価を遅延させる）、という点以外は同様。非決定性計算の場合、式が複数の値を取り得て、素数のペアを探索する処理は非決定性計算が組み込まれた処理系が処理する。等々、非決定性計算と遅延リストの比較等ありつつ、どう実装するかに触れていく。

今回は ”深さ優先探索” というアプローチで実装していく、とのこと。

遅延評価が組み込まれた処理系で、以前実装したストリームを再度試してみる。

以前はかなり回りくどい工夫をしたけど、今回は cons / car / cdr を合成手続きで定義して

遅延評価させるだけで良い。

   (define (cons a b)
     (lambda (x) (x a b)))

   (define (car pair)
     (pair (lambda (a b) a)))

   (define (cdr pair)
     (pair (lambda (a b) b)))

SICPの最初の頃出てきた、手続きで表現した対（とリスト）で実装。以前実験したストリーム演算、一通り試したら一応ちゃんと動いていた。

但し今回はリスト＝ストリームなので、より自然に表現できる。

   ;;リストのn番目を表示（動作確認用）
   (define (list-ref items n)
     (print (car items))
     (if (< n 1)
         (car items)
         (list-ref (cdr items) (- n 1))))

   ;;リストをフィルタする
   (define (list-filter p items)
     (if (p (car items))
         (cons (car items)
               (list-filter p (cdr items)))
         (list-filter p (cdr items))))

   ;;map
   (define (list-map proc items)
     (cons (proc (car items))
           (list-map proc (cdr items))))

   ;;複数のリストを引数に取り、それを引数の手続きで一つにするmap
   (define (lists-map proc list1 list2)
     (cons (proc (car list1) (car list2))
           (lists-map proc (cdr list1) (cdr list2))))

   ;;list-mapを利用して、リストの乗算
   (define (scale-lists items factor)
     (list-map (lambda (x) (* x factor)) items))

   ;;lists-mapを利用して、リストの加算
   (define (add-lists list1 list2)
     (lists-map + list1 list2))

   ;;無限に1が続くリスト
   (define ones
     (cons 1 ones))

   ;;整数 numbers は ones と numbers を加算したリスト
   ;; 1
   ;; 1 + (1)
   ;; 1 + (1 + 1)
   ;; 1 + (1 + 1 ....)
   (define numbers
     (cons 1 (add-lists ones numbers)))

   ;;偶数 even-numbers は２で割りきれる整数
   (define even-numbers
     (list-filter
       (lambda (x) (< (- x (* (/ x 2) 2)) 1))
       numbers))

   (list-ref even-numbers 10)

   ;;フィボナッチ数列は、フィボナッチ数列と(cdr フィボナッチ数列)の加算リスト
   ;;
   (define fib-numbers
     (cons 1
           (cons 1
                 (add-lists (cdr fib-numbers)
                            fib-numbers))))

   (list-ref fib-numbers 10)

   ;;素数primesは、素数を判定するprime?手続きでフィルタした整数
   (define primes
     (list-filter prime?
                  (list-filter (lambda (n)(> n 1)) numbers)))

   ;;素数を判定するprime?は、素数列primesで割り切れない整数の場合trueを返す
   (define (prime? n)
     (define (iter ps)
       (if (> (square (car ps)) n)
           #t
           (if (divisible? n (car ps))
               #f
               (iter (cdr ps)))))
     (iter primes))

   (list-ref primes 10)

4.2.1 正規順序と作用的順序

Schemeは作用的順序評価だけど，これまでに作った処理系に手を加えることで、正規順序評価

（遅延評価）を試す．

仕様としては

・基本手続きは作用的順序評価

・合成手続き（lambda式）は正規順序評価

下記の変更を加える

・lambda式の評価時は，引数を遅延オブジェクトに変換するだけで評価は遅延させる．

　- 遅延オブジェクト = (cons 実際の式 . 環境）

・if式の条件部にあたる式は強制評価を行う．

・基本手続きの評価時は、引数の強制評価を行う．

　- 強制評価 = (eval 実際の式 環境)

その名の通り、式の評価を必要になるまで遅延させる.

意外に簡単

;;問4.27 下記の式を遅延評価させるとどうなるか ;;;
(define count 1)
(define (id x)
  (set! count (+ count 1))
  x)

(print count)
(define w (id (id 10)))
(print count)
(print w)
(print count)

1
2
10
3

w が遅延オブジェクト（実体 => (id 10)) に束縛されるので
評価される度に(id x)が実行される。のかな。

手続き内のdefine式による定義は、振る舞いとしては同時に評価されるべき？

((lambda (n)
  (define a (+ b 10)
  (define b (- n 3))
  (+ a b)))
 10)

という式があった時に、a定義中のbは

- 定義はそれぞれ順番に処理されるので、未定義でエラーになる

- 定義は同時に起こるべきなので 7 になり正常

どっちが正しいかという問題4.19 、 確かに定義は同時に起こる

っていう意見も正しい気がする。

欄外のコラムでは「同時に起こるべきだけど、実装が難しいので現実的にはエラーかな」とある。

define式をletrecに展開し、変数のスコープをはっきりさせる例もあった

(define a <exp1>)
(define b <exp2>)
(a (b 123))

を

(let ((a null) (b null))
  (set! a <exp1>)
  (set! b <exp2>)
  (a (b 123)))

に変換すれば、exp1とexp2がそれぞれを参照できる。あと評価がlambda式等で遅延されてれば問題無い？

;;問 4.20 letrecをletを利用したマクロで実装する ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;let を lambda に展開する
(define-syntax let
  (syntax-rules ()
    ((let ((_k _v) ...) _b ...)
     ((lambda (_k ...) _b ...) _v ...))))

;;letrec を let と set! に展開する。局所変数の評価タイミングがset!時に変わるので
;;相互に参照する場合等上手くいく、のかな。。
(define-syntax letrec
  (syntax-rules ()
    ((letrec ((var1 init1)) body ...)
     ((lambda (var1)
        (let ((temp1 "undefined"))
          (set! temp1 var1)
          body ...)) init1))
    ((letrec ((var1 init1) params ...) body ...)
     (letrec (params ...)
       ((lambda (var1)
          (let ((temp1 "undefined"))
            (set! temp1 var1)
            body ...)) init1)))))

;;問 4.21 lambdaだけで再帰手続きを実装する ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;defineを利用せず（無名関数で）再帰処理を行う

;;define;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (fact n)
  (if (= n 1)
      1
      (* n (fact (- n 1)))))

(fact 10)

;;lambda;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
((lambda (n)
   ((lambda (fact)
      (fact fact n))
    (lambda (f k)
      (if (= k 1)
          1
          (* k (f f (- k 1)))))))
 10)

;;YCombinator化;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;こんな形にしたい
(define fact-maker
  (lambda (proc)
    (lambda (n)
      (if (= n 1)
          1
          (* n ((proc proc) (- n 1)))))))

(print ((fact-maker fact-maker) 8))

;;(proc proc) を追い出す
;;((proc proc) 5) は ((lambda (arg)((proc proc) arg)) 5) と等価なので
(define fact-maker2
  (lambda (proc)
    (lambda (n)
      (if (= n 1)
          1
          (* n
             ((lambda (arg)((proc proc) arg))
               (- n 1)))))))

(print ((fact-maker2 fact-maker2) 8))

;;(lambda (arg)((proc proc) arg)) を関数外に追い出す
(define fact-maker3
  (lambda (f)
    (lambda (n)
      (if (= n 1)
          1
          (* n
             (f (- n 1)))))))

;;を再帰的に実行したい。。
(lambda (proc)
  (fact-maker3
   (lambda (arg) ((proc proc) arg))))


;;factで利用したlambda式の使い方で
((lambda (proc)
   (fact-maker3
    (lambda (arg) ((proc proc) arg))))
 (lambda (proc)
   (fact-maker3
    (lambda (arg) ((proc proc) arg)))))


;;固有名を抜き出す
(lambda (f)
  ((lambda (proc)
     (f (lambda (arg) ((proc proc) arg))))
   (lambda (proc)
     (f (lambda (arg) ((proc proc) arg))))))


;;試してみる
(define Y
  (lambda (f)
    ((lambda (proc)
       (f (lambda (arg) ((proc proc) arg))))
     (lambda (proc)
       (f (lambda (arg) ((proc proc) arg)))))))

;;自分自身を受け取ることを期待する
(define fact_y
  (lambda (me)
    (lambda (n)
      (if (= n 1)
          1
          (* n (me (- n 1)))))))

(print
 ((Y fact_y) 8))

;;参考にしました。
;;http://www.loveruby.net/ja/misc/ycombinator.html

lambda式だけで再帰手続きをする、は面白かった。

なるほど、、自分自身を実行するために、引数に入れて続ければ良いのか。

うーん、syntax-ruleを実装してて時間が掛かった。 "..." は単純な可変長引数のような物かと思ってたら、誤解してた

もう少し高度なパターンマッチのシンボルだったのか。

まだマクロ内と実行時のシンボルの衝突が解決できてない気がするけど、まあいいや。次に進もう。