递归定义一元随机数列表：最惯用的 Haskell，类似于纯代码

Question

我正在尝试递归地制作一个随机数列表，该列表使用前一个值来获取下一个值（因此需要递归而不是 map 或 fold，而且我更喜欢明确表示，除非 map/foldr 让它变得非常简单比较）。

在我看来，使用纯 PRNG 非常简单和惯用（puregaussian 使用 System.Random 生成正常变量并具有 puregaussian :: System.Random.RandomGen t => t -> Double -> Double -> (Double, t) 类型）。

purecurse :: System.Random.RandomGen t => t -> Double -> [Double] -> [Double]
purecurse gen current [] = []
purecurse gen current (x:xs) = let (rand, gen2) = puregaussian gen 0 1
                                   next = current + rand
                               in current:purecurse gen2 next xs

不幸的是，纯 PRNG 在 Haskell 中的开发似乎不如 monadic 的那么好，所以我想使用 random-fu 或 mwc-probability 之类的库以及我发现的解决方案来做同样的事情要么是单一的，要么不够简洁，要么两者兼而有之。

这是一个使用 do 表示法的解决方案，以及为什么我对它不满意：

import Control.Monad.Primitive
import System.Random.MWC.Probability

recurse :: PrimMonad m => Gen (PrimState m) -> [Double] -> [Double] -> m [Double]
recurse gen history@(current:_) [] = return history
recurse gen history@(current:_) (x:xs) = do
                                         rand <- (sample (normal 0 1) gen)
                                         let next = current + rand
                                         recurse gen (next:history) xs

首先，我宁愿使用 >>= 而不是 do 表示法，但是我找不到绑定 rand 类型为 m Double 的变量然后将其提升到最后得到 m [Double] 的方法案子。似乎没有很多文档（我可以找到）或有关如何执行此类操作的示例。 我想也许有必要嵌套 (>>=) 运算符，但这可能会使函数变得非常复杂或不可读。如果这是权衡，也许 do 表示法更干净，但我什至没有设法使这项工作，我想知道如何。

其次，该函数要求在每次调用时传递整个列表，并将列表反向返回（只需切换 next 和 history 就会破坏它）。

所以。我希望能够传递初始状态和一个递归列表，该列表返回一个单子值列表。

我想要帮助的主要问题是：是否有一种 Haskell 惯用的方式来编写这种单子值的递归，从而产生一个类似于纯函数结构的单子列表？

Answer 1

我想要帮助的主要问题是：是否有一种 Haskell 惯用的方式来编写这种单子值的递归，从而产生一个类似于纯函数结构的单子列表？

您可以分两步完成。让您的递归函数返回“一元动作”列表，然后组合/排序这些动作。

让我们考虑一个更简单但与您类似的函数，以便于演示。让我们考虑输入而不是随机性。您求助的列表仅用于大小（内容被忽略），所以我们只使用一个整数。

rc ::  Int -> [Double] -> IO [Double]
rc 0 h        = return h
rc n h@(cr:_) = do rand <- readLn :: IO Double
                   let nx = cr + rand
                   rc (n-1)(nx:h) 

这是一个类似的替代方案，可以按照您想要的方式工作

rc' ::  Int -> Double -> IO [Double]
rc' 0 cr = return []
rc' n cr = do rand <- readLn :: IO Double
              let nx = cr + rand
              xs   <- rc' (n-1) nx
              return (nx : xs)

这里没有做标记

rc'' ::  Int -> Double -> IO [Double]
rc'' 0 cr = return []
rc'' n cr = (readLn :: IO Double) >>= (\rand -> 
              let nx = cr + rand 
              in (rc'' (n-1) nx) >>= (\xs ->
                 return (nx : xs))) 

在任何情况下，您可以做的另一件事是抽象出代码片段，而不是进行单一的呈现。

在每个步骤中，您都需要当前值来生成新值。所以一个步骤是Double -> IO Double 类型的函数。这是一种非常简洁的类型，在单子世界中是基本的。您可以通过x >>= step 将值绑定到一个步骤或使用step1 >=> step2 组合两个步骤。所以，让我们一起去吧。

step :: Double -> IO Double
step cr = do rand <- readLn :: IO Double
             return (cr + rand)

这很容易理解。您“生成”一个数字，添加当前数字并返回结果。而你想做n这样的步骤，所以做一个步骤列表。

steps :: Int -> [Double -> IO Double]
steps n = replicate n step 

现在您可以选择如何组合它们。例如，用>=> 折叠一个步骤列表是很自然的。你会得到这个，

runSteps :: Int -> Double -> IO Double 
runSteps n = foldr (>=>) return (steps n)

它接近你想要的但只返回最终结果，而不是在每一步累积生成的值。下面是(>=>)的（受限）类型和我们想要的运算符(*=>)的类型。

(>=>) :: Monad m => (a -> m a) -> (b -> m  a)  -> a -> m  a
(*=>) :: Monad m => (a -> m a) -> (a -> m [a]) -> a -> m [a]

定义是，

(*=>) :: Monad m => (a -> m a) -> (a -> m [a]) -> a -> m [a]
(*=>) ac uc c = do x  <- ac c
                   xs <- uc x
                   return (x:xs) 

我实际上认为这包含了您不特别喜欢的部分。现在我们将其抽象为这段孤立的代码。甚至远离递归调用。最后我们只是折叠来执行这些步骤。

execSteps :: Int -> Double -> IO [Double] 
execSteps n = foldr (*=>) (\x -> return []) (steps n) 

此函数与原始函数的不同之处在于初始输入是Double，而不是[Double]。但这是有意义的类型。您只需在原始函数中传递一个包装的双精度。它会按照您的要求以“正确”的顺序累积元素。

Answer 2

有没有一种 Haskell 惯用的方式来编写这样的递归 monadic values 产生一个类似于 纯函数的结构

通常，当需要将一元值应用于纯函数时，Applicative 运算符，例如 <$>、<*> 可能会有所帮助。

特别是对于列表的构建，通常会以递归方式应用运算符(:)来构建列表，例如

f [] = []
f (x:xs) = x : f xs

前缀方式：

(:) x (f xs)

但是，(:) 是纯函数，默认不接受 monadic 值，但好在每个数据类型都是 Monad 的实例，它也是 Applicative 的实例。借助上面提到的 Applicative 运算符，可以将一元值应用于纯函数而无需任何更改。例如，

(:) <$> (pure x) <*> (pure .f) xs

将返回一个单子列表而不是纯列表。

回到您的问题，就我个人而言，我认为您的解决方案已经几乎是一种惯用的方法（因为它简单易读），除了总是在history 的头部附加next random value。

正如你所说，the list back in reverse 更糟糕的是，当history 列表已经有旧的随机值时，不方便找出哪个是新添加的。

为了解决这个问题，可以稍微修改为：

recurse :: PrimMonad m => Gen (PrimState m) -> [Double] -> [Double] -> m [Double]
recurse gen history [] = return history
recurse gen history (x:xs) = do rand <- (sample (normal 0 1) gen)
                                let next = (last history) + rand
                                recurse gen (history ++ [next]) xs

这是有道理的，如果历史的最后一个元素是最新的随机值。

但是，(:) 和(++) 之间的区别是：(:) 是 O(1)，但 (++) 是 O(N)，其中 N 是历史列表的长度。 （并且last history 也是 O(N) 而不是 O(1)）。

要归档一个有效的解决方案，可能需要引入一个辅助函数，例如 newHistory，以构造一个新的随机值列表：

newHistory::PrimMonad m=>Gen(PrimState m)->m Double->[Double]->m [Double]
newHistory _ _ []             = return []
newHistory gen current (x:xs) = let next = (+) <$> current <*> sample (normal 0 1) gen
                                in  (:) <$> next <*> newHistory gen next xs

如前所述，在 Applicative 运算符的帮助下，语法看起来像纯函数，除了以前缀方式应用函数并使用 Applicative 运算符。

然后将原来的history列表追加为：

(++) <$> pure history <*> newHistory gen (pure $ last history) xs

recurse 函数的应用版本如下：

recurse2::PrimMonad m=>Gen(PrimState m)->[Double]->[Double]->m [Double]
recurse2 gen history xs = 
    (++) <$> pure history <*> newHistory gen (pure $ last history) xs

    where newHistory::PrimMonad m=>Gen(PrimState m)->m Double->[Double]->m [Double]
          newHistory _ _ []         = return []
          newHistory gen current (x:xs) = 
            let next = (+) <$> current <*> sample (normal 0 1) gen
            in  (:) <$> next <*> newHistory gen next xs

Answer 3

您的问题似乎在于 do-notation 和 monads。您假设发生的魔法比实际情况要多得多：learning how the desugaring works 会在这里为您提供帮助。

无论如何，让我们尝试一步一步地将非单子版本转换为单子版本。一、类型签名：

recurse :: PrimMonad m => Gen (PrimState m) -> Double -> [Double] -> m [Double]

我不确定您为什么在版本中将[Double] 作为第二个参数：我们希望尽可能少地更改原始版本。那么第一个子句：

purecurse gen current [] = []
-- Goes to:
recurse gen current [] = return []

同样，我们尽可能少地进行更改：在您的纯代码中，此子句中没有发生任何影响，因此这里也不应该发生任何影响。你猜对了接下来的两行：

purecurse gen current (x:xs) = let (rand, gen2) = puregaussian gen 0 1
                                   next = current + rand
-- Goes to:
recurse gen current (x:xs) = do rand <- (sample (normal 0 1) gen)
                                let next = current + rand

但最后一个让你绊倒了。理想情况下，我们会这样写：

in current:purecurse gen2 next xs
-- Goes to:
current:recurse gen next xs

但它不起作用！更重要的是，你会得到一个令人困惑的错误：

• Couldn't match type ‘Double’ with ‘[Double]’
  Expected type: m [Double]
    Actual type: [Double]

这可能是导致您走错路的原因。这个问题与列表无关：它与m（封装单子）有关。当你写current : xs 时，xs 必须是一个列表：在这个例子中，它实际上是一个m [Double]，或者是一个包裹在 monad 中的列表。有两种方法可以解决这个问题（它们都是等价的）。我们可以展开列表，再次使用 do 表示法：

rest <- recurse gen next xs
return (current : rest)

或者我们可以提升函数current :在monad中工作：

fmap (current:) (recurse gen next xs)

Answer 4

在这种情况下，我通常会直接使用带有类似列表界面的流媒体库，例如streaming。它们允许从纯代码到单子的更自然的转换，并具有额外的好处，即您不需要一次构造/使用所有结果，而是增量，就像纯列表一样。

我不确定purecurse 在做什么，但可以写成

import           Streaming
import qualified Streaming.Prelude as S

recurse :: PrimMonad m 
        => Gen (PrimState m) 
        -> Double 
        -> [Double] 
        -> Stream (Of Double) m ()
recurse gen current [] = 
    return ()
recurse gen current (x:xs) =
    S.yield current *> -- (*>) and (>>) work like concatenation for pure lists
    lift (sample (normal 0 1) gen) >>= \rand -> 
    recurse gen (current + rand) xs

或者，更自然地使用 do-notation，如：

recurse :: PrimMonad m 
        => Gen (PrimState m) 
        -> Double 
        -> [Double] 
        -> Stream (Of Double) m ()
recurse gen current [] = 
    return ()
recurse gen current (x:xs) = 
    do S.yield current -- (*>) and (>>) work like concatenation for pure lists
       rand <- lift $ sample (normal 0 1) gen
       recurse gen (current + rand) xs

现在您可以使用S.take 之类的函数仅生成/提取部分结果。如果要获取整个列表，可以使用S.toList_。