《Haskell趣學指南》筆記之 Applicative 函子

方應杭在飢人谷發表於2019-05-08
Haskell筆記APP

首先我們來重新思考一下 Functor 例項（函子），然後學習 Applicative

IO 是 Functor 的例項

class Functor f where
    fmap :: (a -> b) -> f a -> f b 

instance Functor IO where   
    fmap f action = do
        result <- action
        return (f result) 
複製程式碼

示例：

main = do 
    line <- getLine
    let line' = reverse line
    putStrLn $ "You said " ++ line' ++ " backwards!" 
    
-- 下面使用 fmap 改寫上面的程式碼

main = do 
    line <- fmap reverse getLine
    putStrLn $ "You said " ++ line ++ " backwards!" 
    
-- 回顧一下列表的函子特性
ghci> fmap (*2) [1.. 3]
[2, 4, 6] 
複製程式碼

作為函子的函式

Haskell 的函式型別定義會出現 -> 符號，比如程式碼 1：

class Functor f where
    fmap :: (a -> b) -> f a -> f b 
複製程式碼

這個 -> 其實也是函子，其定義在 Control.Monad.Instances 裡：

instance Functor ((->) r) where
    fmap f g = (\x -> f (g x))
複製程式碼

仔細觀察就會發現，這個 fmap 實際上就是函式組合。所以

instance Functor ((->) r) where &emsp;
    fmap = (.)
複製程式碼

如果你想不通，可以把程式碼 1 的 f 改成 (->) r，你就得到了

fmap :: (a -> b) -> (->) r a -> (->) r b 
複製程式碼

然後把 (->) r a 改成 r -> a，得到程式碼 2

fmap :: (a -> b) -> (r -> a) -> (r -> b) 
複製程式碼

這個 fmap 接受 f1(a->b) 和 f2(r-a)，得到一個新的函式 f3； f3 接受一個 r，通過 f2 把 r 變成 a，然後通過 f1 把 a 變成 b；這不就是函式組合麼？

ghci> fmap (*3) (+100) 1 
303
ghci> (*3) . (+100) $ 1 
303 
複製程式碼

問題在於，我現在無法把上面的程式碼與列表做對比了：

ghci> fmap (*2) [1.. 3]
[2, 4, 6] 
複製程式碼

列表很容易理解成容器，但是 (+100) 到底是什麼容器呢？如果看程式碼 2 的話，說不定能理解一點：

fmap :: (a -> b) -> (r -> a) -> (r -> b) 
複製程式碼

(r ->) 就是一個容器吧。或者容器這個比喻在這裡已經不適用了。

另一個角度看

如果一個函式的型別是a -> b -> c ，就表示它接受一個 a 型別的值，返回一個 b -> c 函式。所以 a -> b -> c 等價於 a -> (b -> c)。那麼 fmap :: (a -> b) -> (f a -> f b) 可以寫成這樣，也就是說

fmap 接受 a -> b 型別的函式，返回 f a -> f b 型別的函式，其中 f 接受型別變數。具體化一下就是 (Int -> String) -> (Maybe Int -> Maybe String)

也就是說 fmap (*2) [1.. 3] 裡的 (*2) 是 Int -> Int，經過 fmap 一折騰，變成了 [Int] -> [Int]。這種操作叫做提升（lifting）一個函式。

兩種方式思考 fmap

  • (a -> b) -> f a -> f b 接受函式(*2)和函子值[1,2,3]，在函子值上對映這個函式
  • (a -> b) -> (f a -> f b) 接受函式，把它提升為操作函子值的函式兩種看法都對。

Applicative

先看定義

class (Functor f) => Applicative f where
    pure :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b 
複製程式碼
  1. f 必須首先是一個 Functor 的例項，才能成為 Applicative 的例項
  2. pure 接受一個任意型別 A 的引數，然後返回一個被包裝在 f 裡的 A 型別的值，也就是說 pure 就是裝包
  3. <*> 接受一個被裝在 f 裡的 (a ->b) 函式，再接受一個被裝在 f 裡的 a 值，返回一個裝在 f 裡的 b 值
  4. <*>也可用另一個角度思考，接受一個裝在 f 裡的 (a->b)，返回一個 f a -> f b

使用示例：

instance Applicative Maybe where &emsp; 
    pure = Just &emsp; 
    Nothing <*> _ = Nothing &emsp; 
    (Just f) <*> something = fmap f something 

ghci> Just (+3) <*> Just 9 
Just 12 
ghci> pure (+3) <*> Just 9 
Just 12
複製程式碼

為了方便對比，我把 Maybe 作為 Functor 例項的程式碼也複製過來

instance Functor Maybe where
    fmap f Nothing = Nothing 
    fmap f (Just x) = Just (f x)
複製程式碼

那麼 instance Applicative Maybe 的意思就很明顯了：

  1. pure = Just 的意思是，如果你想把一個值裝到 Maybe 裡，用 Just 接受這個值即可
  2. <*> Nothing _ = Nothing 是說，如果第一個盒子裡沒值，那麼得到的盒子裡一定也沒值
  3. <*> (Just f) something = fmap f something 是說，如果一個盒子裡是 f，另一個盒子裡不管是什麼，<*> 的功能都是
    1. 拿出 something 裡的值
    2. 用 f 呼叫這個值
    3. 把值返回之前跟同類的盒子裡這裡我不太明白的地方在於，something 就沒有什麼約束嗎？

Applicative Style

我們可以用 <*> 把一個函式和兩個值連起來（但是要注意順序，而且 <*> 是左結合的）

λ> :t pure (+) <*> Just 3
Just (+) <*> Just 3 :: Num a => Maybe (a -> a)
λ> pure (+) <*> Just 3 <*> Just 5
Just 8
λ> pure 3 <*> Just (+) <*> Just 5
error...
複製程式碼

為什麼要用 pure 開頭呢？因為 pure 會把東西放在預設的上下文中（也就是 Just）。根據定義 (Just f) <*> something = fmap f something

pure (+) <*> Just 3 可以改寫為 fmap (+) (Just 3)

因此 Control.Applicative 有一個 <$> 函式，實際上就是 fmap 的中綴版本：

(<$>) :: (Functor f) => (a -> b) -> f a -> f b 
f <$> x = fmap f x 
複製程式碼

用上 <$> 之後，整個過程就更簡潔了：如果想把 f 對映到兩個 Application 例項的值上，可以寫成

f <$> x <*> y
複製程式碼

如果想把 f 對映到兩個普通值上，可以寫成

f x y
複製程式碼

列表也是 Applicative 的例項

instance Applicative [] where &emsp; 
    pure x = [x] &emsp; 
    fs <*> xs = [f x | f <- fs, x <- xs] 
    
ghci> [(*0),(+ 100),(^ 2)] <*> [1, 2, 3] 
[0, 0, 0, 101, 102, 103, 1, 4, 9] 
ghci> [(+),(*)] <*> [1, 2] <*> [3, 4] 
[4, 5, 5, 6, 3, 4, 6, 8] 
ghci> (++) <$> ["ha"," heh"," hmm"] <*> ["?","!","."] 
["ha?"," ha!"," ha."," heh?"," heh!"," heh."," hmm?"," hmm!"," hmm."] 
ghci> [ x* y | x <- [2, 5, 10], y <- [8, 10, 11]] 
[16, 20, 22, 40, 50, 55, 80, 100, 110] 
ghci> (*) <$> [2, 5, 10] <*> [8, 10, 11] 
[16, 20, 22, 40, 50, 55, 80, 100, 110] 
ghci> filter (>50) $ (*) <$> [2, 5, 10] <*> [8, 10, 11] 
[55, 80, 100, 110] 
複製程式碼

IO 也是 Applicative 的例項

instance Applicative IO where &emsp; 
    pure = return 
    a <*> b = do
        f <- a
        x <- b
        return (f x) 
        
myAction :: IO String 
myAction = pure (++) <*> getLine <*> getLine  -- 也可以寫成 (**) <$> getLine <*> getLine
-- myAction 等價於
myAction :: IO String 
myAction = do &emsp; 
    a <- getLine &emsp; 
    b <- getLine &emsp; 
    return $ a ++ b 
複製程式碼

(->) r 也是 Application 的例項

instance Applicative ((->) r) where &emsp; 
    pure x = (\_ -> x) &emsp; 
    f <*> g = \x -> f x (g x) 
複製程式碼

說實話沒看懂，但是示例看得懂：

ghci> :t (+) <$> (+3) <*> (*100) 
(+) <$> (+3) <*> (*100) :: (Num a) => a -> a 
ghci> (+) <$> (+3) <*> (*100) $ 5 
508 
複製程式碼

這個函式把+ 用在(+ 3) 和(* 100) 的結果上，然後返回。對於(+) <$> (+3) <*> (*100) $ 5，(+ 3) 和(* 100) 先被應用到 5 上，返回 8 和 500，然後+ 以這兩個值為引數被呼叫，返回 508。

ghci> (\x y z -> [x, y, z]) <$> (+3) <*> (*2) <*> (/2) $ 5 
[8. 0, 10. 0, 2. 5] 
複製程式碼

實用函式

ghci> liftA2 (:) (Just 3) (Just [4]) 
Just [3, 4] 
ghci> (:) <$> Just 3 <*> Just [4] 
Just [3, 4] 
ghci> sequenceA [Just 3, Just 2, Just 1] 
Just [3, 2, 1] 
ghci> sequenceA [Just 3, Nothing, Just 1] 
Nothing 
複製程式碼

相關文章