第6回スタートHaskell発表資料 「すごいHaskell楽しく学ぼう13章」

1. モナドがいっぱい！
すごいHaskell楽しく学ぼう！１３章

2. 自己紹介
佐藤建太 @brain_apple
東京大学 農学部 (生物系)
バイトや趣味としてプログラミングしてます
perl Javascript OCamlもやりたい

3. モナド、こわい？

4. モナド、難しい？

5. Monad tutorials timeline
http://www.haskell.org/haskellwiki/Monad_tutorials_timeline

6. Monad tutorials timeline
リア ル
ュート
ナ ドチ
える モ
増
http://www.haskell.org/haskellwiki/Monad_tutorials_timeline

7. やはりひとつの難関.....

8. しかし、１２章までの知識で
モナド理解の障壁は
低くなっているはず

9. Haskellの型クラス関係図
http://www.haskell.org/haskellwiki/Typeclassopedia

10. 今日触れるところ
Haskellの型クラス関係図
http://www.haskell.org/haskellwiki/Typeclassopedia

11. Functor, Applicative, Monad, MonadPlusは、
ApplicativeがFunctorを継承し、
MonadがApplicativeを継承し、
MonadPlusがMonadを継承している
という関係にある。

12. Monad

13. その前に、

14. Functor復習
class Functor f where
(<$>) :: (a -> b) -> f a -> f b

15. Applicative復習
class (Functor f) => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> a -> b

16. そしてMonad
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b

17. そしてMonad
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b
>>= は「バインド」と呼びます

18. ApplicativeとMonadを見比べてみると、
-- Applicative
pure :: a -> f a
-- Monad
return :: a -> m a
Applicative の pure と
Monad の return は同じような型で、

19. Functor, Applicative, Monadを見比べてみると、
-- Functor
(<$>) :: (a -> b) -> f a -> f b
-- Applicative
(<*>) :: f (a -> b) -> f a -> f b
-- Monad
(>>=) :: m a -> (a -> m b) -> m b
ムムッ、よくわからないが似たカンジがする。

20. ＼ __ ／
＿ （Ｍ）＿ ﾋﾟｺｰﾝ
|ミ|
／ ｀´ ＼
( ﾟ∀ﾟ)
ノヽノ |
< <

21. <$>と<*>の引数の型の順序を入れ替えてみると、
-- Functor -- Functor'
(<$>) :: (a -> b) -> f a -> f b (<$>) :: f a -> (a -> b) -> f b
-- Applicative -- Applicative'
(<*>) :: f (a -> b) -> f a -> f b (<*>) :: f a -> f (a -> b) -> f b
-- Monad -- Monad
(>>=) :: m a -> (a -> m b) -> m b (>>=) :: m a -> (a -> m b) -> m b

22. 第２引数の違いだけ！
-- Functor'
(<$>) :: f a -> (a -> b) -> f b
-- Applicative'
(<*>) :: f a -> f (a -> b) -> f b
-- Monad
(>>=) :: m a -> (a -> m b) -> m b

23. 第２引数の違いだけ！
-- Functor'
(<$>) :: f a -> (a -> b) -> f b
-- Applicative'
(<*>) :: f a -> f (a -> b) -> f b
-- Monad
(>>=) :: m a -> (a -> m b) -> m b

24. 第２引数の違いだけ！ 違う
-- Functor'
(<$>) :: f a -> (a -> b) -> f b
-- Applicative'
(<*>) :: f a -> f (a -> b) -> f b
-- Monad
(>>=) :: m a -> (a -> m b) -> m b

25. 第２引数の違いだけ！ 違う
-- Functor'
(<$>) :: f a -> (a -> b) -> f b
-- Applicative'
(<*>) :: f a -> f (a -> b) -> f b
-- Monad
(>>=) :: m a -> (a -> m b) -> m b

26. 第２引数の違いだけ！ 違う
-- Functor'
(<$>) :: f a -> (a -> b) -> f b
-- Applicative'
(<*>) :: f a -> f (a -> b) -> f b
-- Monad
(>>=) :: m a -> (a -> m b) -> m b
同じ 同じ

27. Functor復習
-- Functor'
(<$>) :: f a -> (a -> b) -> f b
シンプルな関数で、文脈(コンテナ)
である f とは関係がない。

28. Applicative復習
-- Applicative'
(<*>) :: f a -> f (a -> b) -> f b
文脈(コンテナ)の中の値を、
その中で写すだけ。

29. そしてMonad
-- Monad
(>>=) :: m a -> (a -> m b) -> m b
文脈(コンテナ)の中の値を取って、
同じ文脈だが 別の値 を返す関数

30. ふむふむ、

31. Maybeモナドで見てみよう。

32. instance Monad Maybe where
-- :: x -> Maybe a
return = Just
-- :: Maybe a -> (a -> Maybe b) -> Maybe b
Nothing >>= f = Nothing
Just x >>= f = f x

33. -- return :: x -> Maybe a
return = Just
returnは受け取った値をJustで
Maybeの文脈につつむだけ。

34. -- :: m a -> (a -> m b) -> m b
Nothing >>= f = Nothing
Just x >>= f = f x
第二引数の関数 f は、生の値(文脈無しの値) x を
取って、文脈付きの 別の値 を返す。
関数f は、受け取った値 x に依っては
Nothingを返すこともできる！

35. -- :: m a -> (a -> m b) -> m b
Nothing >>= f = Nothing
Just x >>= f = f x
第二引数の関数 f は、生の値(文脈無しの値) x を
取って、文脈付きの 別の値 を返す。
関数f は、受け取った値 x に依っては
Nothingを返すこともできる！

36. 具体例 綱渡り問題
養魚場ではたらくピエールは休暇を使って綱渡りをします。(?)
バランス棒を持って綱渡りします。
でも、たまにバランス棒の両端に鳥が止まります。
左右端の止まった鳥の数の差が４羽以上になるとバランスを崩
して綱渡り失敗です。

37. 仕様
鳥の数はBirds型、バランス棒はPole型
landLeft n でn羽の鳥が左端に止まる。（右端も同様）
落ちてない・落ちたの状態をそれぞれJustとNothingで表す
モナドのバインド(>>=)で計算をつなげる

38. やりましょう

39. やりました
type Birds = Int
type Pole = (Birds, Birds)
landLeft :: Birds -> Pole -> Maybe Pole
landLeft n (left, right)
| abs ((left + n) - right) < 4 = Just (left + n, right)
| otherwise = Nothing
landRight :: Birds -> Pole -> Maybe Pole
landRight n (left, right)
| abs (left - (right + n)) < 4 = Just (left, right + n)
| otherwise = Nothing

40. やりました 成功か失敗か
止まる鳥の数 棒の状態
type Birds = Int
type Pole = (Birds, Birds)
landLeft :: Birds -> Pole -> Maybe Pole
landLeft n (left, right)
| abs ((left + n) - right) < 4 = Just (left + n, right)
| otherwise = Nothing
landRight :: Birds -> Pole -> Maybe Pole
landRight n (left, right)
| abs (left - (right + n)) < 4 = Just (left, right + n)
| otherwise = Nothing

41. こんな感じです
> landLeft 2 (0, 0)
Just (2, 0) -- 大丈夫(・ω<)
> landLeft 6 (2, 4)
Nothing -- 失敗(´；ω；｀)

42. そして、

43. > :t landLeft 3
landLeft 3 :: Pole -> Maybe Pole
ここの型が合う
> :t (>>=)
(>>=) :: m a -> (a -> m b) -> m b

44. なので、

45. > :t (>>= landLeft 3)
(>>= landLeft 3) :: Maybe Pole -> Maybe Pole

46. MaybeからMaybeへの関数を実現。
それも、計算の失敗検出機能付き。
> :t (>>= landLeft 3)
(>>= landLeft 3) :: Maybe Pole -> Maybe Pole

47. 全く新しい計算が、
あなたの思いのまま。

48. そう、Monad ならね。

49. > Just (0, 0) >>= landLeft 3
Just (3, 0)
これは成功し、
> Just (0, 0) >>= landLeft 4
Nothing
これは失敗です。

50. > Just (0, 0) >>= landLeft 3
Just (3, 0)
これは成功し、
> Just (0, 0) >>= landLeft 4
Nothing
これは失敗です。

51. > Just (0, 0) >>= landLeft 3
Just (3, 0)
これは成功し、
> Just (0, 0) >>= landLeft 4
Nothing
これは失敗です。

52. > Just (0, 0) >>= landLeft 1 >>= landRight 3
Just (1, 3)
> Just (0, 0) >>= landLeft 9 >>= landRight 9
Nothing
(>>=)で計算をつなげたり、
途中の失敗を最終結果として
得ることもできます

53. いつでも失敗するbananaを定義すると、
途中にバナナがあればいつでも失敗します
banana :: Pole -> Maybe Pole
banana = const Nothing
実行例
> Just (0, 0) >>= banana >>= landLeft 1
Nothing

54. ちょいまとめ

55. コンテキストの中にある値を見て
成功(Just)か失敗(Nothing)かを
返すことは、Functor や
Applicative ではできない

56. Maybeモナドでは、
コンテキストの中の値を受けて
Just を返すか Nothing を返すか
第２引数の関数が決めることができる
(>>=) :: m a -> (a -> m b) -> m b

57. リストモナド

58. instance Monad [] where
return x = [x]
xs >>= f = concat (map f xs)

59. 渡されたリストの要素
全てに map を通して f を適用する
instance Monad [] where
return x = [x]
xs >>= f = concat (map f xs)

60. 渡されたリストの要素
全てに map を通して f を適用する
instance Monad [] where
return x = [x]
xs >>= f = concat (map f xs)
そして concat でまとめ上げる

61. [3,4,5] >>= x -> [x, -x]
3 -> [3, -3]
mapで
分岐して 4 -> [4, -4]
5 -> [5, -5]
concatでまとめ上げる
計算結果 [3,-3,4,-4,5,-5]

62. リストモナドを使えば
(>>=)でつなげると、
複数の候補がある計算を
自然に書ける

63. Σd(ﾟ ﾟd)ｲｶｽ!

64. MonadPlus

65. class Monad m => MonadPlus where
mzero :: m a
mplus :: m a -> m a -> m a
Monadに適用できる関数を追加 = 機能の追加
mzeroが「失敗」に当たり、
mplusが「選択」に当たる。

66. 「失敗」の mzero
> mzero :: Maybe ()
maybeでは
Nothing
Nothingになる
リストでは > mzero :: [()]
空のリスト []

67. 「選択」の mplus (Maybe)
> Just 1 `mplus` Just 2
左が優先
Just 1
右は失敗でも > Just 1 `mplus` Nothing
OK Nothing
> Nothing `mplus` Just 1
左がダメなら右
Just 1
両方ダメなら > Nothing `mplus` Nothing
失敗 Nothing

68. 「選択」の mplus (リスト)
> [1,2] `mplus` [3,4]
[1,2,3,4]
すべての > [1,2] `mplus` []
[1,2]
選択肢を
保持する。 > [] `mplus` [3,4]
[3,4]
> [] `mplus` []
[]
※ただリストをつなげているだけ

69. guard
失敗する値を定義する
guard :: (MonadPlus m) => Bool -> m ()
guard True = return ()
guard False = mzero
３の倍数、もしくは３がつく数字だけを返す
nabe :: Int -> [Int]
nabe = x ->
guard ('3' `elem` show x || x `mod` 3 == 0)
>> return x

70. ちゃんと動いてますね
> [1..100] >>= nabe
[3,6,9,12,13,15,18,21,23,24,27,30,31,32,
33,34,35,36,37,38,39,42,43,45,48,51,53,
54,57,60,63,66,69,72,73,75,78,81,83,84,
87,90,93,96,99]
※なんで関数名が nabe なのか分からなかった人は
「世界のナベアツ」で調べてみよう！

71. ナイトの可能な動きも簡単に表せます
type Pos = (Int, Int)
moveKnight :: Pos -> [Pos]
moveKnight (x, y) = do
(x', y') <- [(x+1,y+2),(x+2,y+1),(x-1,y-2),(x-2,y-1),
(x+1,y-2),(x+2,y-1),(x-1,y+2),(x-2,y+1)]
guard (x' `elem` [1..8] && y' `elem` [1..8])
return (x', y')
盤上にない動きを排除

72. ちなみに、
guard は Control.Monad モジュールで
定義されているので、使うときはここから
インポートしましょう。

73. 実はAlternativeというのがあってだな...
Applicative版の MonadPlus
Control.Applicative モジュールで定義されている
Applicative版なので MonadPlus より適用範囲は広い(はず)
でも Applicative なので guard は使えない
Parsec などパーサーコンビネータを書くときは便利

74. Monad則もあるんだよ
-- 左恒等性
return a >>= k = k a
-- 右恒等性
m >>= return = m
-- 結合性
(m >>= k) >>= h = m >>= (x -> k x >>= h)

75. Monad則もあるんだよ
return が id っぽく振る舞うよ
-- 左恒等性
return x >>= k = k x
-- 右恒等性
m >>= return = m
-- 結合性
(m >>= k) >>= h = m >>= (x -> k x >>= h)

76. Monad則もあるんだよ
return が id っぽく振る舞うよ
-- 左恒等性
return x >>= k = k x
-- 右恒等性
m >>= return = m
-- 結合性
(m >>= k) >>= h = m >>= (x -> k x >>= h)
結合の順序は関係ないよ

77. まとめ
Functor も Applicative も Monad も型が似てる
Monadなら文脈(コンテナ)の中の値に直接アクセスして、
処理をコントーロールできる
処理のコントロールの仕方は、その文脈に依って様々ある

78. 紹介してないモナドたちも
たくさんあるので、
つづく１４章やいろいろなモナドを
覗いてみよう！

79. ご清澄ありがとうございました。

80. 参考
「すごいHaskell楽しく学ぼう！」(オーム社)
Typeclassopedia (http://www.haskell.org/haskellwiki/Typeclassopedia )
※日本語訳もあります