• Haskellの勉強 - 結城浩のHaskell日記
• haskellグループ

• nobsunによる
• Nabetaniさんによる
• KimuraShinichiさんによる
• 既約分数クイズに対する答え

\begin{code}

attr :: String -> String -> String
attr a v = a ++ "=\"" ++ v ++ "\""

xmlns_rdf   = attr "xmlns:rdf" "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns       = attr "xmlns" "http://purl.org/rss/1.0/"
xmlns_dc    = attr "xmlns:dc" "http://purl.org/dc/elements/1.1/"

xmlhead enc = "<?xml " ++ (attr "version" "1.0") ++ " " ++ (attr "encoding" enc) ++ " ?>"

data Rss = Rss Head Channel Body
data Head = Head [(String, String)]
data Channel = Channel [(String, String)]
data Body = Body [Item]
data Item = Item [(String, String)]

addItem :: Rss -> Item -> Rss
addItem (Rss h c (Body is)) i = (Rss h c (Body (is++[i])))

instance Show Rss where
    show (Rss h c b) = (headstr h) ++ (channelstr c) ++ (bodystr b)
        where
            itemstr :: Item -> String
            headstr :: Head -> String
            channelstr :: Channel -> String
            bodystr :: Body -> String

            headstr (Head []) = error "headstr"
            headstr (Head (("encoding",enc):xs)) = (xmlhead enc) ++ "...\n"
            headstr (Head ((x,y):xs)) = headstr (Head xs)
            headstr _ = error "headstr"

            channelstr _ = "...Channel...\n"

            bodystr (Body (x:xs)) = (itemstr x) ++ (bodystr (Body xs))
            bodystr _ = "\n"

            itemstr _ = "...item...\n"

rss1 = Rss
    (Head [
        ("version", "1.0"),
        ("encoding", "Shift_JIS")
    ])
    (Channel [
        ("title", "Site Title"),
        ("link", "http://www.example.com/index.html"),
        ("about", "http://www.example.com/rss.rdf"),
        ("description ", "The description of your site")
    ])
    (Body [
    ])

rss2 = addItem rss1
    (Item [
        ("title", "Item Title"),
        ("link", "http://www.example.com/item.html"),
        ("description", "Yoo, hoo, hoo"),
        ("dc_date", "2003-12-06T01:23:45+09:00")
    ])

\end{code}

Main> rss1
<?xml version="1.0" encoding="Shift_JIS" ?>...
...Channel...


Main> rss2
<?xml version="1.0" encoding="Shift_JIS" ?>...
...Channel...
...item...

(==)と(/=)の定義が以下のようになっているのを見て、最初は驚いた。

class Eq a where
    (==) :: a -> a -> Bool
    x == y = not (x /= y)

    (/=) :: a -> a -> Bool
    x /= y = not (x == y)

無限ループになってしまうような気がしたからだ。 でも、そうではなく、 Eqのinstanceが、(==)と(/=)のどちらか一方でも定義すればよいということになる。

Javaでメソッドのoverrideというと、スーパークラスのメソッドをoverrideすることを意味するが、 Haskellではclassの演算子をinstanceがoverrideするらしい。

練習してみよう。

module Main where

data Color = Red | Pink | Green | Grass | Blue | Skyblue

instance Eq Color where
    Red == Pink = True
    Green == Grass = True
    Blue == Skyblue = True
    _ == _ = False

t1 = Red == Pink
t2 = Red /= Pink
t3 = Green == Skyblue
t4 = Green /= Skyblue

Main> t1
True
Main> t2
False
Main> t3
False
Main> t4
True

ここでは、Colorというtypeに対して演算子(==)だけを定義している。 しかしちゃんと、(==)と(/=)が使えるようになっている。

ちなみに、ColorというtypeはEqというclassのinstanceである。 Javaのclassはtypeとほぼ同義だが、Haskellのclassはtypeの集まりである。 用語が微妙に違うので注意が必要である。

ところで、もしも(==)と(/=)の両方を定義しなかったらどうなるだろう。 以下のように、スタックオーバーフローを起こす。

module Main where

data Color = Red | Pink | Green | Grass | Blue | Skyblue

instance Eq Color

t = Red == Pink

Main> t
ERROR - C stack overflow

\begin{code}
module Main where
import Char

class Incrementable a where
    inc :: a -> a

instance Incrementable Char where
    inc c = chr ((ord c) + 1)

t1 = inc '3'
t2 = inc 'A'

instance Incrementable a => Incrementable [a] where
    inc = map inc

t3 = inc ['A'..'D']
t4 = inc "HAL"

\end{code}

Main> t1
'4'
Main> t2
'B'
Main> t3
"BCDE"
Main> t4
"IBM"

\begin{code}
module Main where

(%) :: Integral a => a -> a -> a
infixl 7 %
(%) = mod

t1 = 7 `mod` 3
t2 = 7 % 3
t3 = 7 `mod` (-3)
t4 = 7 % (-3)
t5 = 7 `mod` 0
t6 = 7 % 0

\end{code}

Main> t1
1
Main> t2
1
Main> t3
-2
Main> t4
-2
Main> t5

Program error: divide by zero

Main> t6

Program error: divide by zero

• 『Introduction to Functional Programming Using Haskell』Richard Bird

Hugsのコマンドに:findというのがあるのを知る。 たとえば、 :find map と入力すると、mapの定義をエディタで見ることができる。

秀丸エディタを設定するには、たとえば、次のようなバッチファイルからHugsを起動すると楽。

"C:\Program Files\Hugs98\Hugs" -E"C:\Hidemaru\Hidemaru.exe /j%%d %%s" %1 %2 %3 %4 %5 %6 %7 %8 %9

• 『Haskell: The Craft of Functional Programming (2nd Ed.) 』Simon Thompson

PointFreeStyleは、引数を書かず（考えず）、関数のcompositionで関数を定義するスタイル。好ましいスタイル。

HigherOrderFunctionsのページでは、 関数の共通の振る舞いをくくりだす話が書かれている。

「関数」というものを直接イメージするのがまだ苦手なので、引数を補って考えている。

状態が暗黙のうちに流れていく様子はだいぶわかったつもり。

\begin{code}
module Main where

-- Lstはリストを表す型。
data Lst a = Nil | MakeLst a (Lst a) deriving (Show, Eq)

-- Stateは状態。数の累積に使う。
type State = Integer

-- Numberingは要素の数を数えるための型。
-- newtype Numbering aを使うと、Numberingはaと本質的に同じ型。
-- 汎用に作っているので、とりあえずLstとは無関係。
newtype Numbering a = Numbering (State -> (a, State))

-- State -> (a, State) という型は「状態を渡されると、値に状態をくっつけて返す関数」を表す型
-- そうか！「状態」は暗黙のうちにbindを経由して渡っていくんだな。

-- Numbering型をMonadのインスタンスにする。これで>>=やreturnが使える（使えるように定義する）
instance Monad Numbering where
    -- return xは、Numbering fという関数で表現しよう。
    -- fというのは、どういう関数か。f s は「xに対して、流れてくる状態sをくっつけて返す関数」である。
    return x = Numbering f
        where
            f s = (x, s)

    -- 「Numbering fの結果を元にnextfする」ということを「Numbering g」という関数で表現しよう。
    -- gというのはどういう関数か。g sは「h t」である。
    -- tとはどういう状態か。「f sしたときの結果の状態である」
    -- hとはどんな関数か。「f sしたときの値に対してnextfする関数」である。
    -- このあたりで道に迷ってしまった …(@_@)
    Numbering f >>= nextf = Numbering g
        where
            g s = h t
                where
                    (l, t) = f s
                    Numbering h = nextf l

number :: Lst a -> Lst Integer
number l = fst (f 0)
    where
        Numbering f = numb l
            where
                numb :: Lst a -> Numbering (Lst Integer)
                numb Nil = do
                    return Nil
                numb (MakeLst _ l) = do
                    n <- nextNumber
                    nl <- numb l
                    return (MakeLst n nl)
                        where
                            nextNumber :: Numbering Integer
                            nextNumber = Numbering f
                                where
                                    f n = (n+1, n+1)

s1 = MakeLst "A" (MakeLst "B" (MakeLst "C" Nil))
n1 = number s1

\end{code}

Main> s1
MakeLst "A" (MakeLst "B" (MakeLst "C" Nil))
Main> n1
MakeLst 1 (MakeLst 2 (MakeLst 3 Nil))

doの表記を手で置換してみると、意味がよく分かる。

\begin{code}
module Main where

data Perhaps a = Error String | Value a deriving (Show,Eq)

instance Monad Perhaps where
    Value x >>= k = k x
    Error s >>= k = Error s
    return x      = Value x
    fail s        = Error s

a1 = Value 123 >>= (\x ->
     Value x   >>= (\y ->
     Value y   >>= (\z ->
     Value z       )))

t1 = do
        x <- Value 123
        y <- Value x
        z <- Value y
        return z

a2 = Value 123        >>= (\x ->
     Value x          >>= (\y ->
     Error "Too bad." >>= (\_ ->
     Value y          >>= (\z ->
     Value z          ))))

t2 = do
        x <- Value 123
        y <- Value x
        Error "Too bad."
        z <- Value y
        return z

a3 = Value 123        >>= (\x ->
     Value x          >>= (\y ->
     Error "Too bad." >>= (\_ ->
     Value y          >>= (\z ->
     Error "Invalid." >>= (\_ ->
     Value z          )))))

t3 = do
        x <- Value 123
        Error "Too bad."
        y <- Value x
        Error "Invalid."
        z <- Value y
        return z

\end{code}

Main> a1
Value 123
Main> t1
Value 123
Main> a2
Error "Too bad."
Main> t2
Error "Too bad."
Main> a3
Error "Too bad."
Main> t3
Error "Too bad."

nobsunから

結城さん

モナドの考察、たいへん興味深く拝見しています。

以下は、ひょっとして、ヒントになるかもしれないと思って書いています。
(モナドになると、だいぶんおよび腰になってしまうのは、私自身、
モナドの意味そのものをよく理解していわけでないからです。)

Haskell のクラスには細かく分類すると 2 種類あります。
「型クラス」と「型構築子クラス」です。

- Ord、Eq、Show などは「型クラス」
- Functor、Monad、MonadPlus などは「型構築子クラス」

「型クラス」は、そのインスタンスである型の値(これは first class)の性質を
規定するものですが、「型構築子クラス」は、そのインスタンスである型構築子
(これは first class ではありません)の性質を規定するものです。

data List a = Nil | Cons a (List a)

というデータ型を定義したとき、Nil、Cons はデータ構築子で、
List は型構築子です。たとえば、Eq のインスタンスであるという宣言は

instance Eq (List a) where
  Nil       == Nil       = True
  Cons x xs == Cons y ys = xs == ys
  _         == _         = False

のようなインスタンス宣言になります。これは、(List a)が Eq のインスタンス
ということですね。一方、Functor のインスタンスであるという宣言は

instance Functor List where
  fmap f Nil         = Nil
  fmap f (Cons x xs) = Cons (f x) (fmap f xs)

これは、型構築子 List が Functor クラスであるという宣言になります。
このように見ると、型構築子クラスは型クラスに比べて抽象度が高いと
いえますね。

\begin{code}
module Main where

data Lst a = Val a | Lst a (Lst a) deriving (Show, Eq)
numbering :: Lst a -> Lst Integer
numbering l = fst (numb l 0)
    where
        numb :: Lst a -> Integer -> (Lst Integer, Integer)
        numb (Val a) n =
            let
                n' = n + 1
                ls' = Val n'
            in
                (ls', n')

        numb (Lst a ls) n =
            let
                n' = n + 1
                (ls', n'') = numb ls n'
                ls'' = Lst n' ls'
            in
                (ls'', n'')

a0 = Val "A"
a1 = Lst "A" (Lst "B" (Lst "C" (Val "D")))
b0 = numbering a0
b1 = numbering a1

newtype Numbering a = Numbering (Integer -> (a, Integer))

instance Monad Numbering where
    return a
        = Numbering (\s -> (a, s))
    Numbering ls0 >>= fls1
        = Numbering $ \s0 ->
            let
                (a1, s1) = ls0 s0
                Numbering ls1 = fls1 a1
            in
                ls1 s1

mnumbering :: Lst a -> Lst Integer
mnumbering t =
    let
        Numbering nt = mnumb t
        in fst (nt 0)

mnumb :: Lst a -> Numbering (Lst Integer)
mnumb (Val a) = do
    n <- getNumber
    return (Val n)
mnumb (Lst a ls) = do
    na <- getNumber
    nls <- mnumb ls
    return (Lst na nls)

getNumber :: Numbering Integer
getNumber = Numbering (\ n -> (n+1, n+1))

c0 = mnumbering a0
c1 = mnumbering a1

\end{code}

Main> a0
Val "A"
Main> a1
Lst "A" (Lst "B" (Lst "C" (Val "D")))
Main> b0
Val 1
Main> b1
Lst 1 (Lst 2 (Lst 3 (Val 4)))
Main> c0
Val 1
Main> c1
Lst 1 (Lst 2 (Lst 3 (Val 4)))