Haskell 如何组合postgresql snaplet和WebSocket？

以下代码尝试组合两个单独工作的示例：

但我几乎把所有与websocket相关的东西都拿走了，以得到一个小例子

请在下面找到代码。

msgHandler

由

helloDb

调用，它将获取包含db连接的snaplet的数据，并将其传递给

msgHandler

。（最后）给出了一些方便的实例，以及如何在初始化器monad中使用其中一个实例的示例

当我去掉这两行注释时，ghc说有两个实例涉及范围外类型，并且实例确实重叠：

HasPostgres（ReaderT r m）

和

HasPostgres（ReaderT（Snaplet Postgres）m）

所以问题是，如何让程序进行编译，以便我可以将数据库连接从snaplet传递到websocket部分

我的目标是让websocket侦听消息、查询数据库和发送消息包。我已经尝试过的其他事情：

• aFun:：（MonadIO m，HasPostgres m）=>。。。m（..）

  同时具有db查询和websocket内容（都是liftIO'd）编译，直到

  WS.runWebSocketsSnap

  直接或间接调用

  aFun

• 试图告诉

  msgHandler:：（MonadIO m，HasPostgres m）

  ，但ghc说没有

  HasPosgres IO的实例。我的感觉是，这在没有IO实例的情况下应该是可行的。还是这样

• 下面的代码试图在非snaplet上下文中使用snaplet，但我不确定这是否正确

有没有更好的方法在snapframework中组合WebSocket和（db-）Snaplet？在尝试了几种方法之后，我处于严重的精神紧锁状态，显然需要帮助。任何帮助（即使是关于我应该开始学习/刷新哪些内容的小提示），都将不胜感激

{-# LANGUAGE TemplateHaskell #-}                                                                                                                                                    
{-# LANGUAGE OverloadedStrings #-}                                                                                                                                                  

module Main where                                                                                                                                                                   

import Data.Maybe                                                                                                                                                                   
import Data.Monoid ((<>))                                                                                                                                                           
import Control.Lens                                                                                                                                                                 
import Control.Monad.Trans                                                                                                                                                          
import Control.Monad.Reader 
import Snap.Snaplet                                                                                                                                                                 
import Snap.Snaplet.PostgresqlSimple                                                                                                                                                
import Snap.Http.Server                                                                                                                                                             
import Snap.Core as SC                                                                                                                                                              
import Data.ByteString as BS                                                                                                                                                        
import Data.Text (Text)                                                                                                                                                             
import qualified Data.Text as T                                                                                                                                                     
import qualified Data.Text.IO as T                                                                                                                                                  
import qualified Network.WebSockets as WS                                                                                                                                           
import qualified Network.WebSockets.Snap as WS                                                                                                                                      

newtype App = App { _db :: Snaplet Postgres }                                                                                                                                       

makeLenses ''App                                                                                                                                                                    

msgHandler :: (MonadIO m) => App -> BS.ByteString -> WS.PendingConnection -> m ()                                                                                                   
msgHandler appSt mUId pending = do                                                                                                                                                  
  conn <- liftIO $ WS.acceptRequest pending                                                                                                                                         
  -- res <- liftIO $ runReaderT (query "SELECT name FROM users WHERE id = ?" (Only mUId)) dbSnaplet                                                                                 
  -- liftIO $ print (res :: [Name])                                                                                                                                                 
  liftIO $ T.putStrLn "msgHandler ended"                                                                                                                                            
    where dbSnaplet = view db appSt                                                                                                                                                 

initApp :: SnapletInit App App                                                                                                                                                      
initApp = makeSnaplet "myapp" "My application" Nothing $                                                                                                                            
  App <$> nestSnaplet "db" db pgsInit                                                                                                                                               
      <* addRoutes [("/hello/:id", helloDb)]                                                                                                                                        

newtype Name = Name { _nm :: Text } deriving (Show, Eq)                                                                                                                             

instance FromRow Name where fromRow = Name <$> field                                                                                                                                

helloDb :: Handler App App ()                                                                                                                                                       
helloDb = do                                                                                                                                                                        
  Just mUId <- getParam "id"                                                                                                                                                        
  userName <- with db $ listToMaybe <$> query "SELECT name FROM users     WHERE id = ?" (Only mUId)                                                                                     
  writeText $ maybe "User not found" (\h -> "Hello, " <> (T.pack . show) h) (userName :: Maybe Name)                                                                                
  sStApp <- getSnapletState                                                                                                                                                         
  WS.runWebSocketsSnap $ msgHandler (view snapletValue sStApp) mUId                                                                                                                 

main :: IO ()                                                                                                                                                                       
main = serveSnaplet defaultConfig initApp                                                                                                                                           

{-#语言模板haskell}
{-#语言重载字符串}
模块主要在哪里
导入数据，也许吧
导入数据。Monoid（（））
进口管制.镜头
进口管制.Monad.Trans
导入控制.Monad.Reader
导入Snap.Snaplet
导入Snap.Snaplet.PostgresqlSimple
导入Snap.Http.Server
将Snap.Core导入为SC
将Data.ByteString作为BS导入
导入数据。文本（Text）
导入符合条件的数据。文本为T
将限定的Data.Text.IO作为T导入
将合格的Network.WebSockets作为WS导入
将符合条件的Network.WebSockets.Snap作为WS导入
newtype App=App{{u db:：Snaplet Postgres}
MakeLents'应用程序
msgHandler:：（MonadIO m）=>App->BS.ByteString->WS.PendingConnection->m（）
msgHandler appSt mUId pending=do
conn您遇到的重叠实例问题是一个已修复但尚未发布的问题。您可能需要询问维护人员

同时，您可以选择最新版本