algorithm - Haskell-如何避免IO困惑

我正在haskell上实现一些算法这个算法需要生成一些数据。
我有一个以生成函数为参数的算法函数。例如，算法只是将输入数据乘以n：

 algo :: a -> ??? -> [a]
 algo n dgf = map (\x -> x * n) $ dgf

dgf用于生成数据。如何正确编写函数头，因为dgf可以是任何具有任意数量参数的函数？
另一个变体不接受生成函数，而是接受已经生成的数据。

algo :: a -> [b] -> [a]
algo n d = (\x -> n*x) d

所以，现在让我们假设我使用stdGen生成数据，它使用io。如何使函数更通用，以便它可以同时接受IO实例和普通值，如[1,2,3]。这也与具有功能的变体有关，因为它也可以生成IO。
总而言之，哪种解决方案更好-具有生成函数还是预生成数据？
提前谢谢。

最佳答案

作为对比，我将采用相反的方法dfeuer's answer。
只需使用列表。
想想你的第一个例子：

algo :: a -> ??? -> [a]
algo n dgf = map (\x -> x * n) $ dgf

您会问“如何正确地编写函数头，因为dgf可以是具有任意数量参数的任何函数？”
好吧，一种方法是使用不修剪。
通常，haskell函数是通用的。如果我们有一个像

add :: Int -> Int -> Int
add x y = x + y

我们需要一个函数，在它的输入上加上两个，我们只需要使用add 2。

>>> map (add 2) [1..10]
[3,4,5,6,7,8,9,10,11,12]

因为add实际上不是一个接受两个参数的函数，
它是一个参数的函数，返回一个参数的函数。
我们可以在上面add的参数中添加括号，以使其更清楚：

add :: Int -> (Int -> Int)

在haskell中，所有函数都是一个参数的函数。
但是，我们也可以走另一条路-uncurry一个函数
返回一个函数以获取一个带对的函数：

>>> :t uncurry
uncurry :: (a -> b -> c) -> (a, b) -> c
>>> :t uncurry add
uncurry add :: (Int, Int) -> Int

这也很有用，比如如果我们想在列表中找到每对的和：

>>> map (uncurry add) [ (1,2), (3,4), (5,6), (7,8), (9,10) ]
[3,7,11,15,19]

一般来说，我们可以取消a0-> a1 -> ... -> aN -> b类型的任何函数。
在一个函数中，尽管可能没有
一个可爱的图书馆功能为我们做这件事。
考虑到这一点，我们可以通过未结婚的方式来实现(a0, a1, ..., aN) -> b
函数和值的元组：

algo :: Num a => a -> (t -> [a]) -> t -> [a]
algo n f t = map (\x -> x * n) $ f t

然后使用匿名函数取消我们的参数函数：

>>> algo 2 (\(lo,hi) -> enumFromTo lo hi) (5, 10)
[10,12,14,16,18,20]
>>> algo 3 (\(a,b,c,d) -> zipWith (+) [a..b] [c..d]) (1, 5, 10, 14)
[33,39,45,51,57]

现在我们可以这样做，但我们不需要如上所述，
algo仅使用algo和f一次。那为什么不直接把名单传给它呢？

algo' :: Num a => a -> [a] -> [a]
algo' n ns = map (\x -> x * n) ns

它计算相同的结果：

>>> algo' 2 $ (\(lo,hi) -> enumFromTo lo hi) (5, 10)
[10,12,14,16,18,20]
>>> algo' 2 $ enumFromTo 5 10
[10,12,14,16,18,20]
>>> algo' 3 $ (\(a,b,c,d) -> zipWith (+) [a..b] [c..d]) (1, 5, 10, 14)
[33,39,45,51,57]
>>> algo' 3 $ zipWith (+) [1..5] [10..14]
[33,39,45,51,57]

此外，由于haskell是非严格的，因此不计算t的参数
在它被实际使用之前，我们不必担心“浪费”时间
不会实际使用的参数：

algo'' :: Num a => a -> [a] -> [a]
algo'' n ns = [n,n,n,n]

algo'不使用传递给它的列表，因此它从不强制，所以无论
计算用于计算它从不运行：

>>> let isPrime n = n > 2 && null [ i | i <- [2..n-1], n `rem` i == 0 ]
>>> :set +s
>>> isPrime 10000019
True
(6.18 secs, 2,000,067,648 bytes)
>>> algo'' 5 (filter isPrime [1..999999999999999])
[5,5,5,5]
(0.01 secs, 68,936 bytes)

现在到你问题的第二部分-如果你的数据是在某个monad中生成的呢？
与其说服algo''对一元值进行操作，不如使用流
基于dfeuer解释的方法或者你可以用一张单子。
仅仅因为你在单子里，并不意味着你的价值观突然变得严格。
例如，想要一个无限的随机数列表吗？没问题。

newRandoms :: Num a -> IO [a]
newRandoms = unfoldr (\g -> Just (random g)) <$> newStdGen

现在我可以把这些传递给一些算法：

>>> rints <- newRandoms :: IO [Int]
(0.00 secs, 60,624 bytes)
>>> algo'' 5 rints
[5,5,5,5]
(0.00 secs, 68,920 bytes)

对于一个只从一两个文件中读取输入的小程序来说，没有问题
只需使用algo和懒惰的I/O就可以得到一个要操作的列表。
例如

>>> let grep pat lines = [ line | line <- lines, pat `isInfixOf` line ]
>>> :set +s
>>> dict <- lines <$> readFile "/usr/share/dict/words"
(0.01 secs, 81,504 bytes)
>>> grep "poop" dict
["apoop","epoophoron","nincompoop","nincompoopery","nincompoophood","nincompoopish","poop","pooped","poophyte","poophytic","whisterpoop"]
(0.72 secs, 423,650,152 bytes)

关于algorithm - Haskell-如何避免IO困惑，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/46079371/