这是因为 runST 的 rank-2 类型阻止您为 randShuffleST 提供有意义的类型。 （编写的代码存在第二个问题：可变 ST 数组不能有意义地存在于 ST monad 之外，因此从 runST 内部返回一个是不可能的，并且不太可能构造一个传递给纯函数最好。这是“无趣的”，但最终可能会让人感到困惑；请参阅此答案的底部以了解如何解决它。）
那么，让我们看看为什么你不能写下类型签名。值得一提的是 I agree with shachaf 关于编写类似您正在编写的函数的最佳方法：留在 ST 内部，并且在最后只使用一次 runST。如果您这样做，那么我在答案的底部包含了一些示例代码，显示了如何成功编写代码。但是我认为理解为什么会出现错误是很有趣的；像您遇到的错误是您不想以这种方式编写代码的一些原因！
首先，让我们看一下产生相同错误消息的函数的简化版本：
bounds arr = runST (getBounds arr)
现在，让我们尝试为bounds 指定一个类型。显而易见的选择是
bounds :: (MArray a e (ST s), Ix i) => a i e -> (i,i)
bounds arr = runST (getBounds arr)
我们知道arr 必须是MArray，我们不关心它有什么元素或索引类型（只要它的索引在Ix 中），但我们知道它必须存在于ST 单子。所以这应该有效，对吧？没那么快！
ghci> :set -XFlexibleContexts +m
ghci> :module + Control.Monad.ST Data.Array.ST
ghci> let bounds :: (MArray a e (ST s), Ix i) => a i e -> (i,i)
ghci| bounds arr = runST (getBounds arr)
ghci|
<interactive>:8:25:
Could not deduce (MArray a e (ST s1))
arising from a use of `getBounds'
from the context (MArray a e (ST s), Ix i)
bound by the type signature for
bounds :: (MArray a e (ST s), Ix i) => a i e -> (i, i)
at <interactive>:7:5-38
...
等一下：Could not deduce (MArray a e (ST <em>s1</em>))? s1哪里来的？答案是它来自bounds 定义中的runST。一般来说，runST 的类型是runST :: (forall σ. ST σ α) -> α；当我们在这里使用它时，我们将它限制为(forall σ. ST σ (i,i)) -> (i,i) 类型。这里发生的情况是 forall 就像一个 lambda（实际上，它是一个 lambda），在括号内本地绑定 σ。所以当getBounds arr返回ST s (i,i)类型的东西时，我们可以将α与(i,i)统一——但我们不能将σ与s统一，因为σ 不在范围内。在 GHC 中，runST 的类型变量是 s 和 a，而不是 σ 和 α，因此它将 s 重命名为 s1 以消除歧义，它是 this em> 键入您所看到的变量。
所以这个错误是公平的：我们声称对于某些特定的s，MArray a e (ST s) 成立。但是runST 需要 每个 s 都这样。但是，该错误非常不清楚，因为它引入了一个您实际上无法引用的新类型变量（因此“可能的修复”是没有意义的，尽管它从来都没有帮助）。
现在，显而易见的问题是，“那么我可以写一个正确的类型签名吗？”答案是“……有点”。 （但您可能不想这样做。）所需的类型如下所示：
ghci> :set -XConstraintKinds -XRank2Types
ghci> let bounds :: (forall s. MArray a e (ST s), Ix i) => a i e -> (i,i)
ghci| bounds arr = runST (getBounds arr)
ghci|
<interactive>:170:25:
Could not deduce (MArray a e (ST s))
arising from a use of `getBounds'
from the context (forall s. MArray a e (ST s), Ix i)
...
这个约束表明MArray a e (ST s) 适用于每个 s，但我们仍然会遇到类型错误。似乎"GHC does not support polymorphic constraints to the left of an arrow"——事实上，在谷歌搜索试图找到该信息时，我发现了an excellent blog post at "Main Is Usually A Function"，它遇到了与您相同的问题，解释了错误，并提供了以下解决方法。 （他们还会收到高级错误消息“格式错误的类断言”，这清楚地表明这样的事情是不可能的；这可能是由于不同的 GHC 版本。）
当我们想要从 GHC 的内置系统中获得更多类型类约束时，这个想法很常见，通过 (ab) 使用 GADT 来为此类类型类的存在提供明确的证据：
ghci> :set -XNoFlexibleContexts -XNoConstraintKinds
ghci> -- We still need -XRank2Types, though
ghci> :set -XGADTs
ghci> data MArrayE a e m where
ghci| MArrayE :: MArray a e m => MArrayE a e m
ghci|
ghci>
现在，只要我们有一个MArrayE a e m 类型的值，我们就知道该值必须是用MArrayE 构造函数构造的；这个构造函数只能在有可用的MArray a e m 约束时调用，因此MArrayE 上的模式匹配将使该约束再次可用。 （唯一的另一种可能性是您的该类型的值未定义，这就是为什么模式匹配实际上是必要的。）现在，我们可以将其作为显式参数提供给 bounds 函数，所以我们称之为如bounds MArrayE arr:
ghci> :set -XScopedTypeVariables
ghci> let bounds :: forall a e i.
ghci| Ix i => (forall s. MArrayE a e (ST s)) -> a i e -> (i,i)
ghci| bounds evidence arr = runST (go evidence)
ghci| where go :: MArrayE a e (ST s) -> ST s (i,i)
ghci| go MArrayE = getBounds arr
ghci|
ghci> -- Hooray!
请注意我们必须将主体分解为它自己的函数并在那里进行模式匹配的奇怪之处。发生的情况是，如果您在bounds 的参数列表中进行模式匹配，则来自evidence 的s 会过早地固定为特定值，因此我们需要将其推迟；并且（我认为因为使用更高级别的类型进行推断很困难）我们还需要为go 提供显式类型，这需要作用域类型变量。
最后，回到你原来的代码：
ghci> let randShuffleST :: forall a e i g. Ix i => (forall s. MArrayE a e (ST s))
ghci| -> a i e
ghci| -> g
ghci| -> (a i e, g)
ghci| randShuffleST evidence arr gen = runST $ go evidence
ghci| where go :: MArrayE a e (ST s) -> ST s (a i e,g)
ghci| go MArrayE = do _ <- getBounds arr
ghci| return (arr, gen)
ghci|
ghci> -- Hooray again! But...
现在，正如我在开始时所说，还有一个问题需要解决。在上面的代码中，永远不会有构造forall s. MArrayE a e (ST s) 类型值的方法，因为约束forall s. MArray a e (ST s) 是不可满足的。出于同样的原因，在您的原始代码中，即使没有遇到类型错误，您也无法编写 randShuffleST，因为您无法编写在 ST 之外返回 STArray 的函数。
这两个问题的原因是一样的：an STArray's first parameter is the state thread it lives on。 STArray 的MArray 实例是instance MArray (STArray s) e (ST s)，因此您将始终拥有ST s (STArray s i e) 形式的类型。由于runST :: (forall s. ST s a) -> a，运行runST mySTArrayAction 会以非法方式“泄漏”s。看看
runSTArray :: Ix i => (forall s. ST s (STArray s i e)) -> Array i e
和它未装箱的朋友
runSTUArray :: Ix i => (forall s. ST s (STUArray s i e)) -> UArray i e.
你也可以使用
unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
做同样的事情，只要你保证这是你在可变数组上调用的最后一个函数； freeze 函数放宽了这个限制，但必须复制数组。同样的道理，如果你想将一个数组而不是一个列表传递给你的函数的纯版本，你可能还需要
thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e);
在这里使用unsafeThaw 可能是灾难性的，因为您传递的是一个您无法控制的不可变数组！这一切都会给我们带来类似的东西：
ghci> :set -XNoRank2Types -XNoGADTs
ghci> -- We still need -XScopedTypeVariables for our use of `thaw`
ghci> import Data.Array.IArray
ghci> let randShuffleST :: forall ia i e g. (Ix i, IArray ia e)
ghci| => ia i e
ghci| -> g
ghci| -> (Array i e, g)
ghci| randShuffleST iarr gen = runST $ do
ghci| marr <- thaw iarr :: ST s (STArray s i e)
ghci| _ <- getBounds marr
ghci| iarr' <- unsafeFreeze marr
ghci| return (iarr', gen)
ghci|
ghci> randShuffleST (listArray (0,2) "abc" :: Array Int Char) "gen"
(array (0,2) [(0,'a'),(1,'b'),(2,'c')],"gen")
这需要 O(n) 时间来复制输入的不可变数组，但是通过优化 - 需要 O(1) 时间冻结输出的可变数组，因为 STArray 和 Array 在底层是相同的。
特别是将此应用于您的问题，我们有以下内容：
{-# LANGUAGE FlexibleContexts #-}
import System.Random
import Control.Monad
import Control.Applicative
import Control.Monad.ST
import Data.Array.ST
import Data.STRef
import Data.Array.IArray
updateSTRef :: STRef s a -> (a -> (b,a)) -> ST s b
updateSTRef r f = do
(b,a) <- f <$> readSTRef r
writeSTRef r a
return b
swapArray :: (MArray a e m, Ix i) => a i e -> i -> i -> m ()
swapArray arr i j = do
temp <- readArray arr i
writeArray arr i =<< readArray arr j
writeArray arr j temp
shuffle :: (MArray a e (ST s), Ix i, Random i, RandomGen g)
=> a i e -> g -> ST s g
shuffle arr gen = do
rand <- newSTRef gen
bounds@(low,_) <- getBounds arr
when (rangeSize bounds > 1) .
forM_ (reverse . tail $ range bounds) $ \i ->
swapArray arr i =<< updateSTRef rand (randomR (low,i))
readSTRef rand
-- Two different pure wrappers
-- We need to specify a specific type, so that GHC knows *which* mutable array
-- to work with. This replaces our use of ScopedTypeVariables.
thawToSTArray :: (Ix i, IArray a e) => a i e -> ST s (STArray s i e)
thawToSTArray = thaw
shufflePure :: (IArray a e, Ix i, Random i, RandomGen g)
=> a i e -> g -> (a i e, g)
shufflePure iarr g = runST $ do
marr <- thawToSTArray iarr
g' <- shuffle marr g
iarr' <- freeze marr
return (iarr',g')
shufflePure' :: (IArray a e, Ix i, Random i, RandomGen g)
=> a i e -> g -> (Array i e, g)
shufflePure' iarr g =
let (g',g'') = split g
iarr' = runSTArray $ do
marr <- thaw iarr -- `runSTArray` fixes the type of `thaw`
void $ shuffle marr g'
return marr
in (iarr',g'')
同样，您可以在 shufflePure 中将 freeze 替换为 Data.Array.Unsafe.unsafeFreeze；这可能会产生加速，因为如果它是Array i e，它就不必复制数组来返回它。 runSTArray 函数安全地包装了unsafeFreeze，所以这在shufflePure' 中不是问题。 （两者是等价的，以一些关于拆分 PRNG 的细节为模。）
我们在这里看到了什么？重要的是，只有可变代码会引用可变数组，并且它保持可变（即，在ST s 中返回一些内容）。由于shuffle 进行就地洗牌，它不需要返回一个数组，只需要返回PRNG。为了构建一个纯接口，我们将thaw 一个不可变数组转换为一个可变数组，将 that 就地打乱，然后将freeze 生成的数组重新转换为一个不可变数组。这很重要：它可以防止我们将可变数据泄漏回纯粹的世界。您不能直接可变地打乱传入的数组，因为它是不可变的；相反，你不能直接将可变混洗数组作为不可变数组返回，因为它是可变的，如果有人可以改变它怎么办？
这不会与我们在上面看到的任何错误发生冲突，因为所有这些错误都来自对runST 的不当使用。如果我们限制使用runST，只有在我们组装了一个纯结果后才运行它，所有内部状态线程都可以自动发生。由于runST 是唯一具有rank-2 类型的函数，因此它是唯一可以产生严重类型怪异的地方；其他一切都只需要您标准的基于类型的推理，尽管可能需要更多考虑以保持s state-thread 参数一致。
你瞧：
*Main> let arr10 = listArray (0,9) [0..9] :: Array Int Int
*Main> elems arr10
[0,1,2,3,4,5,6,7,8,9]
*Main> elems . fst . shufflePure arr10 <$> newStdGen
[3,9,0,5,1,2,8,7,6,4]
*Main> elems . fst . shufflePure arr10 <$> newStdGen
[3,1,0,5,9,8,4,7,6,2]
*Main> elems . fst . shufflePure' arr10 <$> newStdGen
[3,9,2,6,8,4,5,0,7,1]
*Main> elems . fst . shufflePure' arr10 <$> newStdGen
[8,5,2,1,9,4,3,0,7,6]
终于成功了！ （真的太久了。很抱歉这个答案的长度。）