Haskell - 如何避免与IO混淆纯粹

时间:2017-09-06 15:41:31

标签: algorithm haskell monads io-monad

我在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。

总而言之,哪种解决方案更好 - 具有生成功能或预先生成的数据?

提前致谢。

2 个答案:

答案 0 :(得分:6)

一种选择是采用而不是列表。如果生成值涉及执行IO,并且可能有许多值,这通常是最好的方法。有几个包提供某种流,但在这个例子中我将使用streaming包。

import qualified Streaming.Prelude as S
import Streaming

algo :: Monad m => a -> Stream (Of a) m r -> Stream (Of a) m r
algo a = S.map (a +)

您可以将Stream (Of a) m r视为“在m中使用操作生成类型a的连续值,最后生成类型r的结果”的方法。此algo函数不承诺生成数据的任何特定方式;它们可以纯粹创造:

algo a (S.each [these, are, my, elements])

IO内,

algo a $ S.takeWhile (> 3) (S.readLn :: Stream (Of Int) IO ())

或使用随机monad,或任何你喜欢的。

答案 1 :(得分:2)

相比之下,我将采用与dfeuer's answer相反的方法。

只需使用列表。

考虑你的第一个例子:

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

你问“如何正确编写函数头,因为dgf可以是任何带有任意参数的函数?”

嗯,一种方法是使用uncurrying。

通常,Haskell函数是curry。如果我们有像

这样的功能
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 :: 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 功能和价值元组:

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仅使用ft一次。那么为什么不把它直接传递给它呢?

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是非严格的,因此不评估algo'的参数 直到它实际使用,所以我们不必担心“浪费”时间计算 实际上不会被使用的参数:

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对monadic值进行操作,而是可以使用流 基于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)

对于只读取一两个文件输入的小程序,没有问题 只需使用readFile和惰性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)