Question

我正在实现一个函数combine :: [[a]] -> [[b]] -> (a -> b -> c) -> [[c]]，它给出了两个2D列表，将给定函数f :: a -> b -> c应用于2D列表的条目。换句话说：

          [[a, b, c],    [[r, s, t],          [[f a r, f b s, f c t], 
combine    [d, e, g],     [u, v, w],   f   =   [f d u, f e v, f g w],
           [h, i, j]]     [x, y, z]]           [f h x, f i y, f j z]]

现在我怀疑是combine = zipWith . zipWith，因为我已经尝试了它并且它给了我预期的结果，例如。

(zipWith . zipWith) (\x y -> x+y) [[1,2,3],[4,5,6]] [[7,8,9],[10,11,12]]

给出了预期结果[[8,10,12],[14,16,18]]，但我无法理解为什么会这样，因为我不明白zipWith . zipWith的类型是怎样的(a -> b -> c) -> [[a]] -> [[b]] -> [[c]]。

(.)这里是否仍然执行通常的功能组合？如果是这样，你能解释一下这对zipWith是如何适用的吗？

Answer 1

要推断表达式的类型，例如zipWith . zipWith，您可以通过以下方式模拟头部的统一。

第一个zipWith的类型为(a -> b -> c) -> ([a] -> [b] -> [c])，第二个(s -> t -> u) -> ([s] -> [t] -> [u])和(.)的类型为(m -> n) -> (o -> m) -> (o -> n)。

要进行类型检查，您需要：

m = (a -> b -> c)
n = ([a] -> [b] -> [c])
o = (s -> t -> u)
m = ([s] -> [t] -> [u]) =＆gt;由于第一个约束，a = [s]，b = [t]，c = [u]

然后返回的类型为o -> n，它距离约束(s -> t -> u) -> ([a] -> [b] -> [c])并且更进一步(s -> t -> u) -> ([[s]] -> [[t]] -> [[u]])。

Answer 2

另一种看待它的方法是，带有压缩操作的列表形成Applicative，而Applicative的{{3}}（嵌套）仍为Applicative：

λ import Control.Applicative
λ import Data.Functor.Compose
λ let l1 = ZipList [ZipList [1,2,3], ZipList [4,5,6]]
λ let l2 = ZipList [ZipList [7,8,9], ZipList [10,11,12]]
λ getCompose $ (+) <$> Compose l1 <*> Compose l2
ZipList {getZipList = [ZipList {getZipList = [8,10,12]},
                       ZipList {getZipList = [14,16,18]}]}

ZipList newtype是必需的，因为＆＃34;裸＆＃34;列表有一个不同的Applicative实例，它形成所有组合而不是压缩。

Answer 3

是的，.是正常的函数组合运算符：

Prelude> :type (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

查看它的一种方法是它需要a值，首先调用a -> b函数，然后使用该函数的返回值来调用b -> c函数。结果是c值。

另一种查看(zipWith . zipWith)的方法是执行eta扩展：

Prelude> :type (zipWith . zipWith)
(zipWith . zipWith) :: (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]

Prelude> :t (\x -> zipWith $ zipWith x)
(\x -> zipWith $ zipWith x)
  :: (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]

Prelude> :t (\x -> zipWith (zipWith x))
(\x -> zipWith (zipWith x))
  :: (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]

zipWith本身的类型：

Prelude> :type zipWith
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

因此，在上面的lambda表达式中，x必须是(a -> b -> c)，因此zipWith x必须具有[a] -> [b] -> [c]类型。

外部 zipWith还需要一个(a1 -> b1 -> c1)函数，如果zipWith x为a1，[a]匹配b1，{{1} } {是[b]，c1是[c]。

因此，通过替换，zipWith (zipWith x)必须具有[[a]] -> [[b]] -> [[c]]类型，因此lambda表达式的类型为(a -> b -> c) -> [[a]] -> [[b]] -> [[c]]。

为什么zipWith.zip可以工作？

3 个答案: