StartHaskell２（12/10/13)　資料

1. ファンクターから
アプリカティブファンクターへ
@UsrNameu1

2. 自己紹介
@UsrNameu1
・新卒社会人一年目
・大学では物理を専攻
・院に行くはずだったけどちょっと悩んで社会人
・職場近いんで神保町でひょっこり会うかも知れません
・Haskellを始めた理由は数学に近そうな言語だったから
・趣味は登山と囲碁です

3. ファンクター復習（７章より）
ファンクターとは？
・全体を写せる（map over）性質をもつ型クラス
型クラス実装
class Functor f where
fmap :: (a -> b) -> f a -> f b
f:型コンストラクタ（:k f で f:: *->* を返す)

4. CASE1：LIST
Functor インスタンス宣言
instance Functor [] where
fmap = map
map :: (a->b) -> [a] -> [b]
↑(:k [] で []:*->*が返ってくる）
ghci> fmap (*2) [1..3]
[2,4,6]

5. CASE2：MAYBE
Functor インスタンス宣言
instance Functor Maybe where
fmap f (Just x) = Just (f x)
fmap f Nothing = Nothing
↑（:k MaybeでMaybe::*->*が返ってくる）
ghci>fmap (*2) (Just 200)
Just 400
＿人人人人人人人人人人人＿
＞箱の中身だけを変えて返す＜
￣^Y^Y^Y^Y^Y^Y^Y^Y^Y^Y^Y￣

6. CASE3：IO（ここから11章）
Functor インスタンス宣言
instance Functor IO where
fmap f action = do
result <- action
return (f result)
↑resultに束縛されたactionにfを適用して返す
⇢何が嬉しいのか？

7. CASE3：IO（ここから11章）
main = do line <- getLine
let line’ = reverse line
putStrLn $ “You said “ ++ line’ ++ “ backwards!”
putStrLn $ “Yes, you said “ ++ line’ ++ “ backwards!”
↓
main = do line <- fmap reverse getLine
putStrLn $ “You said “ ++ line ++ “ backwards!”
putStrLn $ “Yes, you said “ ++ line ++ “ backwards!”
↓
…ちょっと、嬉しい

8. CASE3：IO（ここから11章）
p195 todo.hs source
view :: [String] -> IO ()
view [fileName] = do
contents <- readFile fileName
let todoTasks = lines contents
numberedTasks = zipWith
(n line -> show n ++ " - " ++ line)
[0..] todoTasks
putStr $ unlines numberedTasks
↓
view :: [String] -> IO ()
view [fileName] = do
numberedTasks <- fmap (zipWith
(n line -> show n ++ " - " ++ line)
[0..] . lines ) $readFile fileName
putStr $ unlines numberedTasks
↓
なかなか嬉しい！

9. CASE4：((->) r)
そもそも(->)とは？
⇢函数引数と返り値の型を（ー＞）で区切り、返り値の型
を常に宣言の最後に置く（ｐ２５）
↓
視点を変えて
（ー＞）を２つの型をとって函数を返す型コンストラクタ
と見立てる
（実際 :k (->) で(->) :: * -> * -> * を返す）

10. CASE4：((->) r)
ー＞のままではFunctorとして使えないため一つ引数の型
rをとって((->) r)を新しいFunctorと見立てる
（∵ :k ((->) Int) ▶ ((->) Int) :: * -> *）
↓
Functor インスタンス宣言
instance Functor ((->) r) where
fmap f g = (x -> f (g x))
fmap = (.)
fmap::(a->b)->((->)r a)->((->)r b)
= fmap::(a->b)->(r->a)->(r->b)

11. 「文脈」のお話
Functor クラス実装
class Functor f where
fmap :: (a -> b) -> f a -> f b
のfを文脈（Computational context）と呼ぶ
例：
(->) r 型入力を一つすると函数型を返す文脈
[] 型入力を一つするとリスト型を返す文脈

12. 「持ち上げ」のお話
（ー＞）を２つの型をとって函数を返す型コンストラクタ
と見立てる
class Functor f where
fmap :: (a -> b) -> f a -> f b
↓ クラス実装の視点を変えて
fmap :: (a -> b) -> (f a -> f b)
と見て、fmapを「元の函数と似てるけどFunctor値をとっ
てFunctor値を返す函数」を返すメソッドと見立てること
もできる。この操作を持ち上げ（lifting）と呼ぶ。

13. 「持ち上げ」のお話
例：
ghci> let shout = fmap (++ “!”)
ghci> :t shout
shout :: Functor f => f [Char] -> f [Char]
ghci> shout [“ha”,“ka”,“ta”,”no”]
[“ha!”,“ka!”,”ta!”,”no!”]
「持ち上げられた函数」
※これまでの
fmapが函数とFunctor値を引数とする二引数函数である
見方が否定されたわけではない。

14. ファンクター則
Functorクラスのインスタンスには２つのきまりがある
第一法則（恒等函数の保存）
fmap id (f a) = id (f a)
第二法則（合成函数の分配）
fmap (g . h) (f a) = fmap g (fmap h (f a))
※法則は数学的要請（圏論）による、下記リンクを参照
http://ja.wikibooks.org/wiki/Haskell/%E5%9C%8F%E8%AB%96

15. ファンクター則
例：(->) r
instance Functor ((->) r) where
fmap f g = f . g
第一則： fmap id g = id . g = id (g)
第二則： fmap (f . g) h = f . g . h
= f (g . h)
= fmap f (g . h)
= fmap f (fmap g h)

16. ファンクター則を満たさないファンクター
data CMaybe a = CNothing
| CJust Int a deriving (Show)
instance Functor CMaybe where
fmap f CNothing = CNothing
fmap f (CJust count x)
= CJust (count+1) (f x)
fmap id (CJust 0 “haha”)
≠ id (CJust 0 “haha”) より
第一則： fmap id (f a) = id (f a)
を満たさず、Functorとして不適切

17. アプリカティブファンクター
二引数函数をfmapを用いてFunctor値に適用してみる
例：ghci>:t fmap (++) (Just “hey”)
fmap (++) (Just “hey”) :: Maybe([Char] -> [Char])
Functor内部に函数が入った！
↑
カリー化された複数引数函数に部分適用が施され、函数を
値として返すため （ｐ６２参照）

18. アプリカティブファンクター
このFunctor内部の函数を使ってFunctor値を写したい！
しかし、普通に適用しようとすると…
例：
ghci> let a = fmap (++) (Just “hey”)
ghci> fmap a (Just “ you!”)
<interactive>:31:6:
Couldn't match expected type `a0 -> b0'
with actual type `Maybe ([Char] -> [Char])'
In the first argument of `fmap', namely `a'
In the expression: fmap a (Just " you!")
In an equation for `it': it = fmap a (Just " you!")
＿人人人人人人人＿
となり、うまくいかない ＞アプリカティブ ＜
そこで！ ＞ ファンクター ＜
￣^Y^Y^Y^Y^Y^Y^Y

19. アプリカティブファンクター
Control.Applicativeモジュール内
class (Functor f) => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
pureは文脈内に型を置く函数
(<*>)はfmapの函数引数が文脈内にあっても適用可能な
グレードアップバージョン

20. アプリカティブファンクター
例１：Maybe Applicative Functor
instance Applicative Maybe where
pure = Just
Nothing <*> _ = Nothing
(Just f) <*> sth = fmap f sth
ghci> let a = fmap (++) (Just “hey”)
ghci> a <*> (Just “ you!”)
Just "hey you!"
※普通のファンクターの場合ファンクター内の関数適用の結果をファンクター外に
取り出す一般的な方法は無い。

21. アプリカティブファンクター
便利な記号<$>
pure (+) <*> Just 3 <*> Just 5
をもっと簡潔にしたい！
アプリカティブ則（ファンクタ則のようなもの）の一つに
pure f <*> x = fmap f x があり
更に短くf <$> xと書ける（Control.Applicative内）
(<$>) :: (Functor f) => (a->b) -> f a -> f b
f <$> x = fmap f x
（ちなみにghci> :t ($) ▶ ($) :: (a -> b) -> a -> b )

22. アプリカティブファンクター
例２：List Applicative Functor
instance Applicative [] where
pure x = [x]
fs <*> xs = [f x| f <- fs, x <- xs]
ghci> pure “Hey” :: [String]
[“Hey”] （::=型注釈,ｐ３０参照）
・定義から可能な組み合わせ全てをリストとして提示する
ghci> filter (>50) $ (*) <$> [2,5,10] <*> [8,10,11]
[55,80,100,110] （::=型注釈,ｐ３０参照）

23. アプリカティブファンクター
例３：IO Applicative Functor
instance Applicative IO where
pure = return
a <*> b = do
f <- a
x <- b
return (f x)
ghci> (++) <$> getLine <*> getLine
hgoaih
golk
"hgoaihgolk"

24. アプリカティブファンクター
例４：((->) r) Applicative Functor
instance Applicative ((->) r) where
pure x = (_ -> x)
f <*> g = x -> f x (g x)
pure :: a -> (r -> a)
(<*>) :: (r -> (a -> b)) -> (r -> a) -> (r -> b)
ghci> (+) <$> (+3) <*> (*100) $ 5
508
(ここで:t (+) <$> (+3) ▶ (+) <$> (+3) :: Num a => a -> a -> a)
ghci> (x y z -> [x,y,z]) <$> (+3) <*> (*2) <*> (/2) $ 5
[8.0,10.0,2.5]
・<*>,<$>は頭の函数に引数函数を渡す為の道具と割切る

25. アプリカティブファンクター
例５：ZipList Applicative Functor
instance Applicative ZipList where
pure x = ZipList (repeat x)
ZipList fs <*> ZipList xs
= ZipList (zipWith (f x -> f x) fs xs)
・[]の<*>は可能な組み合わせすべてを結果に出す
・ZipListの<*>はリストの個々の函数を対応する位置の
値に適用して結果に出す
・ZipListをアプリカティブ・スタイルで使えばzipWith
函数群を使う必要がない

26. アプリカティブ則
アプリカティブファンクターにもファンクター則同様に
写像性 pure f <*> x = fmap f x
恒等函数保存 pure id <*> v = v
分配則 pure (.) <*> u <*> v <*> w
= u <*> (v <*> w)
準同型 pure f <*> pure x = pure (f x)
交換則 u <*> pure y = pure ($ y) <*> u
が成立

27. アプリカティブの便利な函数達
Control.Applicative内には<$>の他にも
liftA2::(Applicative f) => (a->b->c)
-> f a -> f b -> f c
liftA2 f a b = f <$> a <*> b
やその他様々有用な函数（<$,<**>,liftA3..)が存在
また、ユーザ定義により(<*),(*>),等の函数も使えるよ
うになるらしい。詳しくは以下URLを参照
http://www.haskell.org/ghc/docs/6.12.1/html/libraries/base/
Control-Applicative.html

28. アプリカティブの便利な函数達
他にも自分で便利な函数を作れる
sequenceA :: (Applicative f) => [f a] -> f [a]
sequenceA [] = pure []
sequenceA (x:xs) = (:) <$> x <*> sequenceA xs
ghci> sequenceA [Just 1,Just 2]
Just [1,2]
ghci> sequenceA [(>4),(<10),odd] 7
[True,True,True]
ghci> sequenceA [[1,2],[3,4],[5,6]]
[[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]]
ghci> sequenceA [getLine,getLine]
hogehoge
mogemoge
["hogehoge","mogemoge"]
下２つは(:) <$> [1,2] <*> ((:) <$> [3,4] <*> [5,6])などと分解してみると
結果の理由が理解しやすい