如何组合两个组合的应用函子？

Question

我有两个组合的应用函子 Maybe [Integer] 并想将它们与 <$>/<*> 结合起来，但我坚持应用应用操作。以下内容不进行类型检查：

(<*>) (<*>) ((<$>) ((+) <$>) $ Just [1,2,3]) $ Just [4,5,6]

预期结果：

Just [5,6,7,6,7,8,7,8,9]

函子部分起作用，即作为第一个参数传递给<*>的中间值是Just [Integer -> Integer]。我习惯了 S 表达式，所以我很难使用 Haskell 语法。我知道Compose，但我对没有抽象的纯粹组合感兴趣。

Answer 1

作为夏立尧said，使用liftA2 可以减少混乱。

但是如果你还想看看它在底层操作方面会变成什么，我们可以扩展liftA2的定义：

liftA2 :: (a -> b -> c) -> f a -> f b -> f c
liftA2 f x y = f <$> x <*> y

所以解决方案变成了

(liftA2 . liftA2) (+) (Just [1,2,3]) (Just [4,5,6])
= liftA2 (liftA2 (+)) (Just [1,2,3]) (Just [4,5,6])
= (\f x y -> f <$> x <*> y) ((\f x y -> f <$> x <*> y) (+)) (Just [1,2,3]) (Just [4,5,6])
= ((\f x y -> f <$> x <*> y) (+)) <$> Just [1,2,3] <*> Just [4,5,6]
= (\x y ->  (+) <$> x <*> y) <$> Just [1,2,3] <*> Just [4,5,6]

现在，这不像您上面的示例那样采用无点样式，我真的认为将其转换为无点有帮助，但这是http://pointfree.io 的输出：

((<*>) . ((+) <$>)) <$> Just [1, 2, 3] <*> Just [4, 5, 6]

我们可以通过 eta-expanding 看到这是一样的：

(<*>) . ((+) <$>)
= \x y -> ((<*>) . ((+) <$>)) x y
= \x y -> ((<*>) $ ((+) <$>) x) y
= \x y -> ((<*>) ((+) <$> x)) y
= \x y -> (<*>) ((+) <$> x) y
= \x y -> ((+) <$> x) <*> y
= \x y -> (+) <$> x <*> y

Answer 2

liftA2 可能比(<*>) 更容易混淆。

(+) :: Int -> Int -> Int
liftA2 (+) :: [Int] -> [Int] -> [Int]
liftA2 (liftA2 (+)) :: Maybe [Int] -> Maybe [Int] -> Maybe [Int]

liftA2 (liftA2 (+)) (Just [1,2,3]) (Just [4,5,6])

Answer 3

两个Applicatives 的组合始终是一个Applicative（与Monad 的情况不同）。

我们可以利用来自Data.Functor.Compose 的Compose newtype 来发挥我们的优势：

newtype Compose f g a = Compose { getCompose :: f (g a) }

它需要一些包装，但这种解决方案在适当的情况下可能很有用：

example :: Maybe [Int]
example =
  getCompose ((+) <$> Compose (Just [1,2,3]) <*> Compose (Just [4,5,6]))

Answer 4

另一种方法是使用ListT transformer。虽然在这种情况下它工作得很好，但由于某种原因，它是一个贬值的转换器，用红色标记为 “不推荐使用：这个转换器在大多数 monads 上无效”。

import Control.Monad.Trans.List

doit :: (Int-> Int -> Int) -> Maybe [Int] -> Maybe [Int] -> Maybe [Int]
doit f mt1 mt2 = runListT $ f <$> (ListT mt1) <*> (ListT mt2)

λ> doit (+) (Just [1,2,3]) (Just [4,5,6])
Just [5,6,7,6,7,8,7,8,9]