■

Haskellは適当な勉強しかしてないので、基本的な知識が欠けているような。あんまり参考にしてはいけません。

data CondOp = Gt | Ge | Lt | Le | Ne | Eql deriving (Eq) -- deriving(Eq)！！

deriving (Eq)を知らなかったので、これまで(Eq CondOp)を一個一個手で書いてたという。（手作りの素晴らしさを、もう一度思い出してみませんか？）

レコードの一部だけとりかえた値を

data Nanika = Nanika { a::Int, b::Int }

こういうのがあったとしたら、

func :: Env -> Env 
func e = e { a = 40 }

これでいいんだって。

func Nanika { a=a, b=b } = Nanika { a=40, b=b }

こうやって書いてたという。

あと、パターンマッチでマッチした値に名前付けられる

func a = 
  case a of
    x @ Nanika { a=_, b=40 } -> x

こうすれば、まあ、そんなこんな。（←説明するのが面倒になったらしい）

http://morihyphen.hp.infoseek.co.jp/files/a24z-futon.tar.gz
とりあえず、支配辺境までできた。あと一歩だなー。

*Parse> testToplev "module X; machine N{ while (1) {} }" dumpDF 
[(0,[]),(1,[1]),(2,[]),(3,[1])]

参考。
http://www.amazon.co.jp/gp/product/4254121393/503-6845711-3191923?v=glance&n=465392
昔思い付きで買ったんだけど、この本一万円もしてんだよなー。

なんか、こんなの。書いた自分でも何をやってるかわからない。

type DomList = [(DG.Node,[DG.Node])]
type IDomList = [(DG.Node,[DG.Node])]

lookupForce :: Eq a => a -> [(a,b)] -> b
lookupForce key l = case DL.lookup key l of Just n -> n

idom :: Graph gr => gr a b -> DomList -> DG.Node -> DG.Node -- 支配リストから、直接支配してるのを求める
idom g domList target = findIDom dom
    where { findIDom (x:xs) | or $ DL.map (\y -> elem y xs) (suc g x) = findIDom xs
                            | otherwise = x
          ; dom = DL.delete target (lookupForce target domList)
          }

type DomTree = Tree DG.Node

idomList :: Graph gr => gr a b -> DomList  -> Node -> IDomList -- (ノード、それが直接支配してるの) のリスト
idomList gr doms start =
    let n = nodes gr in
    DL.map (\x -> (x, DL.filter (\y -> idom gr doms y == x) (DL.delete start n))) n

buildDomTreeSub :: IDomList -> DG.Node -> DomTree
buildDomTreeSub idomList n =
    let idoms = lookupForce n idomList in
    DT.Node { rootLabel = n
            , subForest = DL.map (buildDomTreeSub idomList) idoms }

buildDomTree :: CFG->DomTree -- 支配木
buildDomTree CFG { body=body, startLabel=start, endLabel=end } =
    let { doms = dom body start
        ; idoms = idomList body doms start }
    in
      buildDomTreeSub idoms start 


df :: Graph gr => gr a b -> DomTree -> [(DG.Node,[DG.Node])] -- 支配木 → 支配辺境
df g (DT.Node {rootLabel=root, subForest=children}) =
    let { dfSuc = [ x | x <- suc g root, DL.notElem x (DL.map DT.rootLabel children) ]
        ; dfChildren = concatMap (df g) children
        ; dfChildrenNodes = concatMap snd dfChildren
        ; idoms = DL.map rootLabel children}
    in 
      [ (root, nub $ dfSuc ++ (DL.filter (\x->notElem x idoms) dfChildrenNodes)) ] ++ dfChildren

僕はHaskellのコードの読み易さは死ぬまで理解できないだろうな…

昔、「Haskellの簡潔さはPerlのアレっぷりと似てるよなー」っていうようなことを考えて、それは、「慣れてないからでは？」と、思ってたんだけど、まあ、慣れてもわからんというか。

↓なんか、fgl(グラフのライブラリ)の中にあった。

(.:) :: (c -> d) -> (a -> b -> c) -> (a -> b -> d)
-- f .: g = \x y->f (g x y)
-- f .: g = (f .) . g
-- (.:) f = ((f .) .)
-- (.:) = (.) (.) (.)
(.:) = (.) . (.)

これは無理。