PFDS 9.2.3 La

1. 9.2.3 Lazy Representations

2. 9.2.1 Binary Random-Access Lists

3. type 'a tree = LEAF of 'a
| NODE of int * 'a tree * 'a tree
type 'a digit = ZERO
| ONE of 'a tree
type rlist = Element.t digit list
let rec consTree = function
| (t, []) -> [ONE t]
| (t, ZERO :: ts) -> ONE t :: ts
| (t1, ONE t2 :: ts) -> ZERO :: consTree (link (t1, t2), ts)
;;
let rec unconsTree = function
| [] -> raise Empty
| [ONE t] -> (t, [])
| (ONE t :: ts) -> (t, ZERO :: ts)
| (ZERO :: ts) ->
let (NODE (_, t1, t2), ts') = unconsTree ts in
(t1, ONE t2 :: ts')
;;

4. 9.2.2 Zeroless Representations

5. type 'a tree = LEAF of 'a
| NODE of int * 'a tree * 'a tree
type 'a digit = ONE of 'a tree
| TWO of 'a tree * 'a tree
type rlist = Elem.t digit list
let rec consTree = function
| (t, []) -> [ONE t]
| (t1, ONE t2 :: ts) -> TWO (t1, t2) :: ts
| (t1, TWO (t2, t3) :: ts) -> ONE t1 :: consTree (link (t2, t2), ts)
;;
let rec unconsTree = function
| [] -> raise Empty
| [ONE t] -> (t, [])
| (ONE t1 :: ts) ->
let (NODE (_, t2, t3), ts') = unconsTree ts in
(t1, TWO (t2, t3) :: ts')
| (TWO (t1, t2) :: ts) -> (t1, ONE t2 :: ts)
;;

6. 9.2.3 Lazy Representations
Binomial Heapsに遅延評価を導入したら、
挿入がAmortized timeでO(1)になった。
Binary Random Access List の cons 関数も
O(1) Amortized Timeで実行可能なはず。

7. Amortized Analysisする中で、
データ構造をPersistentな使い方に対応させるには、
遅延評価を使って関数をIncrementalに変換する。

8. type 'a tree = LEAF of 'a
| NODE of int * 'a tree * 'a tree
type 'a digit = ZERO
| ONE of 'a tree
type rlist = Elem.t digit S.stream
let rec consTree = function
| (t, lazy S.Nil) -> lazy (S.Cons (ONE t, lazy S.Nil))
| (t1, lazy (S.Cons (ONE t2, ts))) -> lazy (S.Cons (ONE t1, consTree (link (t2, ts))))
| (t, lazy (S.Cons (ZERO, ts))) -> lazy (S.Cons (ONE t, ts))
;;
let rec unconsTree = function
| (lazy S.Nil) -> raise Empty
| (lazy (S.Cons (ONE t, lazy S.Nil))) -> (t, lazy S.Nil)
| (lazy (S.Cons (ONE t, ts))) -> (t, (lazy (S.Cons (ZERO, ts))))
| (lazy (S.Cons (ZERO, ts))) ->
let (NODE (_, t1, t2), ts') = unconsTree ts in
(t1, lazy (S.Cons (ONE t2, ts')))
;;

13. type 'a tree = LEAF of 'a
| NODE of int * 'a tree * 'a tree
type 'a digit = ZERO
| ONE of 'a tree
| TWO of 'a tree * 'a tree
type rlist = Elem.t digit S.stream
let rec consTree = function
| (t, lazy S.Nil) -> lazy (S.Cons (ONE t, lazy S.Nil))
| (t1, lazy (S.Cons (TWO (t2, t3), ts))) -> lazy (S.Cons (ONE t1, consTree (link (t2, t3), ts)))
| (t1, lazy (S.Cons (ONE t2, ts))) -> lazy (S.Cons (TWO (t1, t2), ts))
| (t, lazy (S.Cons (ZERO, ts))) -> lazy (S.Cons (ONE t, ts))
;;
let rec unconsTree = function
| (lazy S.Nil) -> raise Empty
| (lazy (S.Cons (TWO (t1, t2), ts))) -> (t1, lazy (S.Cons (ONE t2, ts)))
| (lazy (S.Cons (ONE t, lazy S.Nil))) -> (t, lazy S.Nil)
| (lazy (S.Cons (ONE t, ts))) -> (t, (lazy (S.Cons (ZERO, ts))))
| (lazy (S.Cons (ZERO, ts))) ->
let (NODE (_, t1, t2), ts') = unconsTree ts in
(t1, lazy (S.Cons (ONE t2, ts')))
;;

16. 最下位桁から1が連続するとき、その連続部分の数の表現は一種類だけ。
つまり、すべてが1だけで構成される数のとき、表現は1つに収束する。
例えば、111と1111の間の数は様々な表現をもつが、
両端の111と1111はひとつずつしかない。