第８章　ダイナミック

8.1　式をダイナミックに包む
8.2　ダイナミックパターン照合を使用してダイナミックを開包する
8.3　ダイナミックを使用した型安全な通信
8.4　実装のアーキテクチャ
8.5　ダイナミックに関する意味上の制限

• ほとんど全てのアプリケーションは、（環境等のような）ディスクへ情報を保存し、ディスクから情報を取得する。伝統的に、ファイルに書かれた情報はまず、プログラマによって、ある(String)形式に変換されなければならない。ファイルが再度読込まれると、入力を解析し、Stringを適切なデータ構造に変換する為に、パーサを構築しなければならない。Dynamicによって、（ほとんど）あらゆるCLEANデータ構造を、型安全な方法で、たった一度（！）の関数呼出で、保存・取得できる。データだけでなく、保存されるデータ構造の一部であるコード（未評価関数、高階関数）も保存できる。Dynamicによって、永続的なアプリケーション(persistent application)を書くことが更に容易になる。アプリケーションは、そのような方法で環境を保存し、次の時には、ユーザーは、アプリケーションが使用された最後の時と同じ方法で全てを見るのである。
• 様々に独立して打ち込まれたCLEANアプリケーション、ネットワークを通じて配布されているアプリケーションさえ、型安全な方法で、容易に、データだけでなくコード（未評価関数）を保持できる任意の式を通信できる。Dynamicは、ファイルやCLEANライブラリが提供するメッセージ渡しプリミティブを経由して、通信できる。CLEANアプリケーションがコードを通信できるという事実は、実行中のCLEANアプリケーションを追加する機能を拡張できるということを意味している。従って、プラグイン(plug-in)とモバイル(mobile)コードを非常に簡単に実現でき、全ては型安全である。

8.1　式をダイナミックに包む

CLEANの式とその静的な型の例：

3::Int
map::(a -> b) [a] -> [b]
map ((+) 1)::[Int] ->[Int]
MoveCollorPoint Green::(Real,Real) -> ColorPoint

動的式 = dynamic グラフ式 [:: 型]

式をDynamicに包むことができる方法を示す例。
オプションとして、ダイナミックに包みたい式の静的な型を指定できる。

dynamic 3
dynamic 3::Int
dynamic map::A.a b:(a->b) [a] -> [b]
dynamic map::(Int -> Real) [Int] -> [Real]
dynamic map ((+) 1)
dynamic MoveCollorPoint Green

型Tree Intの式を含むダイナミックを生成する（定）関数の例

:: Tree a = Node a (Tree a) (Tree a) | Leaf

MyTree::Dynamic
MyTree = dynamic (DoubleTree 1 mytree)
where
    Doubletree rootvalue tree = Node rootvalue tree tree

    mytree = (Node 2 (Node 3 Leaf Leaf) Leaf)

• 多相型の式をダイナミックに包む場合、全称量化子も明示的に指定する必要がある（上記例参照）。

8.1.1　抽象データ型を包む

• （World、Fileのような）現実世界に意味のある抽象データ型は、Dynamicに包むことはできない。

• 抽象データ型のオブジェクトを持つ式は、ダイナミックに包むことはできない。これに関しては目下作業中である。Cleanシステムの最新版をチェックして下さい。

8.1.2　多重定義関数を包む

例：多重定義関数をDynamicに保存する。

OverloadedDynamic:: Dynamic
OverloadedDynamic = dynamic plus :: A.a:a a -> a | + a
where
    plus:: a a -> a | + a
    plus x y = x + y

• 現在のところ、多重定義関数がダイナミックに包まれる場合、全称量化子とクラス文脈を含めて、その型を明示的に指定しなければならない。

8.1.3　一意型の式を包む

例：文字を一意ファイルに書き込むことのできる関数をDynamicに包む。

MyDynamic:: Dynamic
MyDynamic = dynamic fwritec :: Char *File -> *File

• 一意性型変数と型変換ステートメントは、Dynamicに包まれる型の部分にはなり得ない。
• 一意性型属性は、包まれるダイナミックの型の中で明示的に指定される場合にのみ考慮される。

反例：Dynamicは、一意性型変数又は属性変数不等式を処理できない。

MyDynamic :: Dynamic
MyDynamic =  dynamic append :: [.a] u:[.a] -> v:[.a] , [u<=v]

8.1.4　未知の型の引数を包む

• 多相型の引数は、ダイナミックに包むことができない。

Dynamic生成関数の反例。多相型の引数は、Dynamicに包むことはできない。

WrongCreateDynamic :: t -> Dynamic
WrongCreateDynamic any = dynamic any

任意の型の引数をDynamicに包むことのできる多重定義関数の例

CreateDynamic :: t -> Dynamic | TC t
CreateDynamic any = dynamic any

MyTree :: Dynamic
MyTree  = CreateDynamic (Node 2 (Node 3 Leaf Leaf) Leaf)

8.1.5　動的型付けを使用して静的型システムを打ち負かす

例：様々な型のオブジェクトを１つのリストに包む３つの方法。
　　第１の方法は、１つのリストに包みたい全ての型が、
　　それらを区別する適切な構成子によってまとめられているような新規の型を定義することである。
　　開包するには、パターン照合の中に、様々な構成子に関するケースの区別を作ることができる。
　　全てが良くて、静的に型付けされているが、ラッパー型内で言及される型を開閉することしかできない。

:: WrapperType = I Int | R Real | C Char

MyWrapperList = [I l, R 3.14, C 'a']

様々な型のオブジェクトを包む次の方法は、存在型（5.1.3参照）を使用して、リスト構造を定義することである。
ここでは、どんな型も包むことができるが、その欠点は、一度包まれると、要素を区別し、
それらを開包する簡単な方法が存在しないということである。

:: ExstList = E.a: Cons a ExstList | Nil

MyExstList = Cons l (Cons 3.14 (Cons 'a' Nil)

第３の方法は、その値をダイナミックに包むことである。どんな型でも包むことができるし、
パターン照合を経由して、それらを開包することもできる。しかし、これは非常に非効率なので、
パターン照合でその型を明示的に名付けることによってのみ、値だけを開包できる（8.2参照）。

MyDynamicList = [dynamic l, dynamic 3.14, dynamic 'a']

8.2　動的パターン照合を使用して、ダイナミックを開包する

動的パターン   = (グラフパターン :: 動的型)
動的型         | { 動的パターン型}+
動的パターン型 = 型
               | 型パターン変数
               | 多重定義型パターン変数
型パターン変数 = 変数
多重定義型変数 = 変数^

例：動的パターン照合を使用して、Dynamicが特定の定義済みの型であるかを検査する。
　　関数transformの第１代替部は、Dynamicが値0の整数を持っているかを照合する。
　　第２代替部は、Dynamicが（0以外の）整数を持っていれば選択される。
　　第３代替部は、[Int]から[Int]への関数を要求している。
　　その次の代替部は、Dynamicが2つの[Int]のペアである場合に選択される。
　　代替部のどれにも照合しない場合、最後の代替部が選択される。その場合、プログラムは空リストを出力する。

transform :: Dynamic -> [Int]
transform (0 :: Int)               = []
transform (n :: Int)               = [n]
transform (f :: [Int]->[Int])      = f [1..100]
transform ((x,y) :: ([Int],[Int])) = x ++ y
transform other                    = []

例：動的パターン照合を使用して、Dynamicが特定のユーザー定義代数データ型であるかを検査する。
　　DynamicがIntのTreeを持つ場合、関数CountDynamicLeafsは、この木の葉の数を数える。
　　そうでなければ、CountDynamicLeafsは0を返す。

:: Tree a = Node a (Tree a) (Tree a) | Leaf

CountDynamicLeafs :: Dynamic -> Int
CountDynamicLeafs (tree :: Tree Int)  = countleafs tree
CountDynamicLeafs other               = 0
where
    countleafs :: (Tree Int) -> Int
    countleafs tree = count tree 0
    where
        count:: (Tree a) Int -> Int
        count Leaf nleafs              = nleafs + 1
        count (Node left right) nleafs = count left (count right nleafs)

MyTree :: Dynamic
MyTree = dynamic (Node 1 (Node 2 (Node 3 Leaf Leaf) Leaf) (Node 4 Leaf Leaf))

Start :: Int
Start = CountDynamicLeafs MyTree

例：動的パターン照合を使用して、Dynamicが多相関数（この場合、恒等関数）であるかを検査する。

TestId :: Dynamic a -> a
TestId (id :: A.b: b -> b) x = id x
TestId else x                = x

• 型パターン変数（8.2.4と8.2.5参照）との混乱を避けるには、多相型変数に、全称量化子(A.)を明示的に導入しなければならない。
• 量化子は、最外レベル（ランク1）でのみ認められている。

1. 動的パターンで指定される（基本型、定義済み、ユーザー定義のどれかの）型構成子全ては、ダイナミックに保存されているそれに対応する実際の構成子の名前と比較される。対応型構成子が異なった名前ならば、パターン照合は失敗し、その次の代替部が試行される。
2. パターン照合では、対応型構成子が同一名を持つ場合、実行時システムは、その型定義（その型は異なったCleanアプリケーション又はCleanモジュールで定義されていたかもしれない）も同一であるかを検査するだろう。システムは、これらの型定義を発見する方法を知っている（8.3と8.4参照）。定義が同一でない場合、その型は、異なっているとみなされる。パターン照合は失敗し、その次の代替部が試行される。
3. 型が同一である場合、ダイナミックの無い標準的なパターン照合（3.2参照）で通常のように、その実際のデータ構成子（定数値）が、パターンで指定されたデータ構成子と比較される。指定した定数の全てが実際の値と照合すると、その照合は成功し、それに対応する関数代替部が選択される。そうでなければ、パターン照合は失敗し、その次の代替部が試行される。

8.2.1　抽象データ型の開包

• 抽象データ型を開閉包することはまだできない。目下作業中である。Cleanシステムの最新版をチェックしておいて下さい。8.1.1も参照。

8.2.2　多重定義関数の開包

• 多重定義型変数の為に、パターンの全称量化子を経由してそれらを導入し、型パターン変数との混乱を回避しなければならない（8.2.4と8.2.5参照）。
• 量化子は、最上レベルでのみ認められている。

例：多重定義関数の開包。ダイナミックが+において多重定義されている関数を持つ場合にのみ、パターン照合は成功する。
それに対応するクラス定義が検査されるだろう。
つまり、クラス+の定義は、ダイナミックが生成された文脈で知られているクラス+と同じでなければならない。
plus 2 3の適用によって、型チェッカは、+の整数値に関するインスタンスを必要とするだろう。

CheckDynamic:: Dynamic -> Int
CheckDynamic (plus :: A.a : a a -> a | + a) = plus 2 3
CheckDynamic else                           = 0

8.2.3　一意型の式の開包

例：文字を一意ファイルに書き込むことのできる関数を開包する。

WriteCharDynamic:: Dynamic Char *File -> *File
WriteCharDynamic (fwc :: Char *File -> *File) char myfile = fwc char myfile
WriteCharDynamic else char myfile                         = myfile

• 一意性型変数と型変換ステートメントは、動的パターン照合では使用できない。
• 仮引数と実引数の型属性は、全く同一でなければならない。一意から非一意への型変換やその逆は起こらないだろう。

8.2.4　型パターン変数を使用した型スキームの検査と単一化

型パターン変数 = 変数

関数dynApplyは、型Dynamicの2つの引数を持ち、型Dynamicの値を出力する。
第１のDynamicは、型(a->b)に単一化できる関数を持たなければならず、
第２引数は、関数が期待する引数型aに単一化できなければならない。
この方法で、実際の型が何であるかを正確に知ることなく、
関数を引数に適用することが技術的に型安全であることを保証できる。
その結果は、静的な未知の型bであるだろうが、この結果を再びダイナミックに包むことによって、
静的型システムは幸せになる。
つまり、それはDynamicである。
動的な型が単一化できない場合、関数を引数に適用することは型安全ではないし、
dynApplyの第２代替部が選択される。
これは、ダイナミックに格納されているエラーメッセージを出力する。

dynApply :: Dynamic Dynamic -> Dynamic
dynApply (f :: a -> b) (x :: a)  = dynamic (f x :: b)
dynApply  df            dx       = dynamic ("cannot apply ",df," to ",dx)

Start = dynApply (dynamic (map ((+) 1)) (dynamic [1..10])

• 静的な型が型パターン変数の値に依存している式の生成は認められていない。

反例：静的な型を型パターン変数の値に依存させることはできない。
WrongDynApplyの型bの実際の値は、実行時には分からない。
この例は、型エラーをもたらすだろう。この関数の合法版については、8.2.5参照。

WrongDynApply :: Dynamic Dynamic -> ???
WrongDynApply (f :: a -> b) (x :: a)  = f x
WrongDynApply df            dx        = abort "cannot perform the dyanmic application"

Start = WrongDynApply (dynamic (map ((+) 1)) (dynamic [1..10]) ++ [11..99]

8.2.5　多重定義型変数を使用した未知の型の検査と単一化

多重定義型変数 = 変数^

• 多重定義型パターン変数は、関数の型定義内に導入されなければならない。
• 定義済み型クラスTC（8.1.1参照）は、大域型パターン変数に関する文脈制限として指定されなければならない。
• 多重定義（6.6参照）で通常であるように、コンパイラが、例えば内部的に曖昧な多重定義である為にそれを解決できない場合がある。

例：関数Startは、FlexDynApplyの結果に[11..99]を加える。
従って、FlexDynApplyが関数Startに[Int]を渡さなければならないことを明らかである。
追加的な文脈制限TC bは、FlexDynApplyをbでの多重定義関数に変える。
関数FlexDynApplyは、動的型bではなく、FlexDynApplyを適用する文脈によって要求される静的型bを渡すだろう。
多重定義機構は、追加的な引数として、文脈に必要とされる静的型bに関する情報を自動的に渡す。
そして、この型は、動的パターン照合においてダイナミックの実際の型を検査するのに使用される。

FlexDynApply :: Dynamic Dynamic -> b | TC b
FlexDynApply (f :: a -> b^) (x :: a) = f x
FlexDynApply df             dx       = abort "cannot perform the dyanmic application"

Start = FlexDynApply (dynamic (map ((+) 1)) (dynamic [1..10]) ++ [11..99]

例：関数lookupは、Dynamicのリストの中から、特定の型aの値を検索する。
この関数が探す型は、関数lookupが使用されている文脈に依存する。
Startでは、lookup関数が二度使用される。
最初のケースでは、（+ 5である為）整数値が要求され、
第２のケースでは、（+ 2.5である為）実数値が必要とされる。
このプログラムは、必要な型の値がリストで見つけられない場合、異常終了する。

lookup :: [Dynamic] -> a  | TC a
lookup [(x :: a^):xs] = x
lookup [x:xs]         = lookup xs
lookup []             = abort "dynamic type error"

Start = (lookup DynamicList + 5, lookup DynamicList + 2.5)  // 結果は(6,5.64)であろう。

DynamicList = [dynamic 1, dynamic 3.14, dynamic 'a']

例：以下の人工的な例では、動的パターン内で使用できる型変数の種類を示している。
第１代替部では、型変数aが使用される（全称量化子によって導入される）。
この代替部は、多相関数に照合するだけである。
第２代替部では、多重定義型変数が使用され（a^で指示される）、
これは、関数変体に導入される多重定義型変数a | TC aを参照する。
これは、AllSortsOfVariablesの第２引数の実際の型と同じ型である関数に照合する。
最後の代替部は、型パターン変数aとbを使用している。この関数は使用されないが、
これはどの関数の型にも照合する。

AllSortsOfVariables :: Dynamic  a -> a | TC a
AllSortsOfVariables (id::A.a : (a -> a)) x = id x
AllSortsOfVariables (f::a^ -> a^)        x = f x
AllSortsOfVariables (f::a -> b)          x = x

8.3　ダイナミックを使用した型安全な通信

Dynamicを読書きする標準関数

definition module StdDynamic

...

writeDynamic :: Dynamic String *World -> *(Bool,*World)

readDynamic :: String *World -> *(Bool, Dynamic, *World)

型Tree Intの値を持つDynamicを、DynTreeValueという名前のFileに書込むCleanアプリケーションの例。
この例は、CLEAN関数writeDynamicを使用して、データをディスクに保存できることを示している。

module TreeValue
import StdDynamic, StdEnv

:: Tree a = Node a (Tree a) (Tree a) | Leaf

Start world
# (ok,world) = writeDynamic "DynTreeValue" MyTree world
| not ok     = abort "could not write MyTree to file named DynTreeValue"
| otherwise  = world
where
    MyTree::Dynamic
    MyTree = dynamic (Node 1 mytree mytree)
    where
        mytree = (Node 2 (Node 3 Leaf Leaf) Leaf)

関数countleafsを持つDynamicを、CountsLeafsinTreesという名前のFileに書込む別のCLEANアプリケーション例。
この関数は、Treeの葉の数を数えることができ、型は(Tree Int) -> Intである。
この例は、WriteDynamicを使用するだけで、
コード（この場合は関数CountLeafs）もディスクに保存できるということを示している。

module CountLeafs
import StdDynamic, StdEnv

:: Tree a = Node a (Tree a) (Tree a) | Leaf

Start world
# (ok,world) = writeDynamic "CountsLeafsinTrees" CountLeafs world
| not ok     = abort "could not write dynamic"
| otherwise  = world
where
    CountLeafs = dynamic countleafs

    countleafs:: (Tree Int) -> Int
    countleafs  tree = count tree 0
    where
        count:: (Tree a) Int -> Int
        count Leaf nleafs              = nleafs + 1
        count (Node left right) nleafs = count left (count right nleafs)
        count else                     = abort "count does not match"

３つ目のCLEANアプリケーションは、ファイルから、Tree IntをもつTreeValueと、
Treeの葉の数を数えることのできる関数countleafs（プラグイン）を読込む。
従って、新しい機能が実行中のアプリケーションApplyに加えられる。
関数dynapplyを使用することによって、新しくプラグインされた関数countleafsが、読込まれた木にも適用される。
アプリケーションApplyそれ自体は、ノードの数を数える関数を持ち、この関数を読込まれる木に適用する。
このアプリケーションは、異なったアプリケーションで定義された全ての型Treeが（使用される型変数の名前を除いて）
全く同じである場合にのみ動作することに注意して欲しい。

module Apply

import StdDynamic, StdEnv

:: Tree a = Node a (Tree a) (Tree a) | Leaf

Start world
# (ok,countleafs,world) = read "CountsLeafsinTrees" world
| not ok                = abort ("could not read CountsLeafsinTrees")
# (ok,treevalue,world)  = read "TreeValue" world
| not ok                = abort ("could not read TreeValue")
| otherwise             = ( countnodes (case treevalue of (v::(Tree Int))= v) 0
                          , dynapply countleafs treevalue
                          )
where
    dynapply :: Dynamic Dynamic -> Dynamic
    dynapply (f::a -> b) (v::a) = dynamic (f v)
    dynapply df   dv            = dynamic "incorrectly typed dynamic application"

    countnodes Leaf nnodes              = nnodes
    countnodes (Node left right) nnodes = countnodes left (countnodes right (nnodes+1))

8.4　実装のアーキテクチャ

8.5　ダイナミックに関する意味的制限

• 次の型を閉包/開包できない。抽象データ型、一意性型、多重定義型。これに関しては目下作業中である。