Question

我试了很久以减少haskell中的这个功能，我想举例说明：

mySum x y = x + y
mySum x y = (+) x y
mySum x = (+) x
mySum = (+) -- it's Messi's goal!

我的功能有点复杂，但我真的无法做到，我一直在寻找，我知道有一些技巧，比如修改右侧，并使用{{1} }。我试过了，我在这里堆积：

flip

步骤：

zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' f x y  = map  (uncurry f) (zip x y)

然后我不知道如何继续......

我正在寻找能够逐步解释如何实现＆＃34;梅西的目标的答案＃34;我知道有很多要问，所以我会我可以尽快添加奖励以感谢您的努力

Answer 1

zipWith' f x y = map (uncurry f) (zip x y)

重写应用程序到组合和eta-reduce：

-- \y -> let g = map (uncurry f); h = zip x in (g . h) y
-- let g = map (uncurry f); h = zip x in g . h

zipWith' f x = map (uncurry f) . zip x

将中缀重写为前缀：

-- g . h = (.) g h

zipWith' f x = (.) (map (uncurry f)) (zip x)

重写应用程序到组合和eta-reduce：

-- \x -> let g = (.) (map (uncurry f)); h = zip in (g . h) x
-- let g = (.) (map (uncurry f)); h = zip in g . h

zipWith' f = (.) (map (uncurry f)) . zip

将中缀重写为前缀：

-- g . h = (.) g h

zipWith' f = (.) ((.) (map (uncurry f))) zip

使用flip将f移到右侧：

-- flip f x y = f y x

zipWith' f = flip (.) zip ((.) (map (uncurry f)))

将应用程序重写为合成：

-- g (h (i x)) = (g . h . i) x

zipWith' f = flip (.) zip (((.) . map . uncurry) f)

重写应用程序到组合和eta-reduce：

-- \f -> let g = flip (.) zip; h = (.) . map . uncurry in (g . h) f
-- let g = flip (.) zip; h = (.) . map . uncurry in g . h

zipWith' = (flip (.) zip) . ((.) . map . uncurry)

删除多余的括号：

zipWith' = flip (.) zip . (.) . map . uncurry

如果您愿意，可以简化为中缀：

zipWith' = (. zip) . (.) . map . uncurry

但是这个结果不太可读。

通常在编写完全无点代码时，您希望利用->中的Control.Arrow applicative和arrow组合器。您可以先将参数分组为元组，以便更容易重新排列和管道，而不是尝试编写类似\ f x y -> ...的函数。在这种情况下，我将使用\ (f, (x, y)) -> ...

\ (f, (x, y)) -> map (uncurry f) (zip x y)

我们可以通过将(x, y)应用于uncurry来取消zip的解包：

\ (f, (x, y)) -> map (uncurry f) (uncurry zip (x, y))
\ (f, xy) -> map (uncurry f) (uncurry zip xy)

现在我们有一个简单的案例：将两个函数（uncurry和uncurry zip）应用于两个参数（f和xy），然后组合结果（使用{ {1}}）。为此，我们可以使用map中的***组合子，类型为：

Control.Arrow

专注于功能，即：

(***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')

这只是让我们将函数应用于一对中的每个元素。完美！

(***) @(->) :: (b -> c) -> (b' -> c') -> (b, b') -> (c, c')

您可以将uncurry *** uncurry zip :: (a -> b -> c, ([x], [y])) -> ((a, b) -> c, [(x, y)])视为使用函数uncurry f组合一对元素。所以我们可以使用f：

来合并结果

uncurry map

您可以将uncurry map . (uncurry *** uncurry zip) :: (a -> b -> c, ([a], [b])) -> [c]视为将元组上的函数转换为多参数函数。这里我们有两个级别的元组，外部curry和内部(f, xy)。我们可以使用(x, y)

解包外部的那个

curry

现在，您可以将curry $ uncurry map . (uncurry *** uncurry zip) :: (a -> b -> c) -> ([a], [b]) -> [c]应用中的fmap f视为“跳过”第一个参数：

->

因此我们可以使用fmap @((->) _) :: (a -> b) -> (t -> a) -> t -> b解压缩第二个元组：

fmap curry

我们已经完成了！或者不完全。在编写无点代码时，可以将事情分解为许多具有更清晰名称的小型可重用函数，例如：

fmap curry $ curry $ uncurry map . (uncurry *** uncurry zip)
  :: (a -> b -> c) -> [a] -> [b] -> [c]

然而，虽然知道这些技术很有用，但这一切都只是非生产性的伎俩很容易迷失。大多数时候，你应该只在Haskell中使用无点样式才能获得可读性，而且这些结果比简单的原始版本更清晰：

zipWith' = untuple2 $ combineWith map apply zipped
  where
    untuple2 = fmap curry . curry
    combineWith f g h = uncurry f . (g *** h)
    apply = uncurry
    zipped = uncurry zip

或部分无点版本：

zipWith' f x y = map (uncurry f) (zip x y)

减少haskell的Eta

1 个答案: