Haskell语言学习笔记（40）Arrow（1）

Arrow

class Category a => Arrow a where
    arr :: (b -> c) -> a b c

    first :: a b c -> a (b,d) (c,d)
    first = (*** id)

    second :: a b c -> a (d,b) (d,c)
    second = (id ***)

    (***) :: a b c -> a b' c' -> a (b,b') (c,c')
    f *** g = first f >>> arr swap >>> first g >>> arr swap
      where swap ~(x,y) = (y,x)

    (&&&) :: a b c -> a b c' -> a b (c,c')
    f &&& g = arr (\b -> (b,b)) >>> f *** g

Arrow（箭头）是个类型类，它是 Category（范畴）的子类。

Arrow 是函数的进一步抽象。

• arr :: (b -> c) -> a b c
  
  arr 函数将函数转换为 Arrow。
• first :: a b c -> a (b,d) (c,d)
  
  first 函数接收一个二元组，然后使用一个 Arrow 来修改元组的第1个成员。
• second :: a b c -> a (d,b) (d,c)
  
  second 函数接收一个二元组，然后使用一个 Arrow 来修改元组的第2个成员。
• (***) :: a b c -> a b' c' -> a (b,b') (c,c')
  
  (***) 函数接收一个二元组，然后分别使用两个 Arrow 来修改这个元组的两个成员。
• (&&&) :: a b c -> a b c' -> a b (c,c')
  
  (&&&) 函数只接收一个参数，拷贝一份，组成一个二元组，然后分别使用两个 Arrow 来修改这个元组的两个成员。

Arrow 的法则

arr id = id
arr (f >>> g) = arr f >>> arr g
first (arr f) = arr (first f)
first (f >>> g) = first f >>> first g
first f >>> arr fst = arr fst >>> f
first f >>> arr (id *** g) = arr (id *** g) >>> first f
first (first f) >>> arr assoc = arr assoc >>> first f
    where
        assoc ((a,b),c) = (a,(b,c))

(->) 是个 Arrow

instance Arrow (->) where
    arr f = f
    (***) f g ~(x,y) = (f x, g y)

Prelude Control.Arrow> (+2) &&& (*2) $ 3
(5,6)
Prelude Control.Arrow> (+2) *** (*2) $ (1,3)
(3,6)
Prelude Control.Arrow> (+2) <<< (*2) $ 3
8
Prelude Control.Arrow> (*2) >>> (+2) $ 3
8
Prelude Control.Arrow> first (*2) (1,3)
(2,3)
Prelude Control.Arrow> second (*2) (1,3)
(1,6)
Prelude Control.Arrow> arr (*2) 3
6

Kleisli Arrow

newtype Kleisli m a b = Kleisli { runKleisli :: a -> m b }

instance Monad m => Category (Kleisli m) where
    id = Kleisli return
    (Kleisli f) . (Kleisli g) = Kleisli (\b -> g b >>= f)

instance Monad m => Arrow (Kleisli m) where
    arr f = Kleisli (return . f)
    first (Kleisli f) = Kleisli (\ ~(b,d) -> f b >>= \c -> return (c,d))
    second (Kleisli f) = Kleisli (\ ~(d,b) -> f b >>= \c -> return (d,c))

Kleisli m a b封装了一个返回值为 Monad 的函数：a -> m b。

如果 m 是 Monad，那么 Kleisli m 是 Category，也是 Arrow。

Prelude Control.Arrow> runKleisli (Kleisli (\x -> [x * 2]) >>> Kleisli (\x -> [x, -x])) 2
[4,-4]
Prelude Control.Monad> (\x -> [x * 2]) >=> (\x -> [x, -x]) $ 2
[4,-4]
Prelude Control.Arrow> runKleisli (arr length >>> Kleisli print) [2,2]
2

Arrow 的函数

returnA :: Arrow a => a b b
returnA = arr id

(^>>) :: Arrow a => (b -> c) -> a c d -> a b d
f ^>> a = arr f >>> a

(>>^) :: Arrow a => a b c -> (c -> d) -> a b d
a >>^ f = a >>> arr f

(<<^) :: Arrow a => a c d -> (b -> c) -> a b d
a <<^ f = a <<< arr f

(^<<) :: Arrow a => (c -> d) -> a b c -> a b d
f ^<< a = arr f <<< a

Prelude Control.Arrow> (returnA :: Int -> Int) 5
5
Prelude Control.Arrow> runKleisli (returnA :: Kleisli [] Int Int) 5
[5]
Prelude Control.Arrow> runKleisli (length ^>> Kleisli print) [2,2]
2
Prelude Control.Arrow> runKleisli (Kleisli print <<^ length) [2,2]
2