在单体变压器堆栈中使用加权采样时的"No instance for MonadRandom"

Question

我想从monad转换器堆栈内的列表中获取一个加权样本。

我已经设法让这个最小的例子进行了类型检查，但我不理解运行main时收到的错误消息，也不知道如何修复它

{-# LANGUAGE NoMonomorphismRestriction, FlexibleContexts #-}                                                                                       
module Testing where                                                                                                                               
import Control.Monad.IO.Class (liftIO, MonadIO)                                                                                                    
import Control.Monad.Trans.Class (lift)                                                                                                            
import Control.Monad.Trans.State.Lazy (modify, runStateT, StateT)                                                                                  
import Control.Monad.Trans.Reader (ask, runReaderT, ReaderT)                                                                                       
import Data.Random                                                                                                                                 
import Data.Random.Distribution.Uniform.Exclusive (Excludable)                                                                                     
import Data.Random.Shuffle.Weighted (weightedSample)                                                                                               
testS :: [(Int, Int)]                                                                                                                              
testS = [(1,c) | c <- [11..20]]                                                                                                                    
loop :: (Num w, Ord w, Show a, MonadIO m, Excludable w, Distribution Uniform w, MonadRandom (StateT [[a]] m)) => ReaderT [(w, a)] (StateT [[a]] m) ()
loop = do
  s <- ask                                                                                                                                         
  a <- lift $ sample $ weightedSample 1 s                                                                                                          
  liftIO $ print a                                                                                                                                 
  lift $ modify ((:) a)                                                                                                                            
main :: (MonadIO m, MonadRandom (StateT [[Int]] m)) => m ((), [[Int]])                                                                             
main = runStateT (runReaderT loop testS) []    

实际的程序应该通过从初始配置（testS）中选择一个随机问题来帮助学习，然后更新状态中的权重，这样用户出错的问题就更有可能出现。

以下是我在ghci:中运行main时得到的错误

 No instance for (random-source-0.3.0.6:Data.Random.Internal.Source.MonadRandom                                                                                                                                                                                                                                           
                   (Control.Monad.Trans.State.Lazy.StateT [[Int]] m0))                                                                                                                                                                                                                                                   
  arising from a use of `main'                                                                                                                                                                                                                                                                                           
Possible fix:                                                                                                                                                                                                                                                                                                            
  add an instance declaration for                                                                                                                                                                                                                                                                                        
  (random-source-0.3.0.6:Data.Random.Internal.Source.MonadRandom                                                                                                                                                                                                                                                         
     (Control.Monad.Trans.State.Lazy.StateT [[Int]] m0))                                                                                                                                                                                                                                                                 
In the expression: main                                                                                                                                                                                                                                                                                                  
In an equation for `it': it = main  

Answer 1

我似乎无法安装random-fu进行测试，但根据浏览文档，我仍然猜测这可能是正确的。

线路

a <- lift $ sample $ weightedSample 1 s

尝试在底层monad 中运行sample $ weightedSample 1 s

StateT [[Int]] IO

然而，当StateT monad的状态是支持的随机数生成器状态之一时，它们只是MonadRandom。

您可能希望在IO中运行它，它本身就是一个MonadRandom。

换句话说，添加另一个lift。

顺便说一句，如果这是对的，那么它最初仍然进行类型检查的原因是，如果您愿意，理论上可以为StateT [[Int]] IO添加一个实例。（但你可能没有。）