Access MongoDB from Snap - haskell

Question

I'm trying to access mongo using the mongodb haskell drivers (the snap driver appears to be broken for snap > 0.5) in splice.
This is as far as I've got so far:
testSplice :: Splice AppHandler
testSplice = do
record <- liftIO $ do
pipe <- runIOE $ connect (host "127.0.0.1")
results <- access pipe master "db" (find $ select [] "coll")
close pipe
rest result
return $ [TextNode $ T.pack $ show $ records]
I understand that I need to use liftIO there, as the mongo action occurs inside an IO monad, and I want to pull that back out. Where my understanding breaks down is the result of compiling that splice:
Couldn't match expected type `IO a0'
with actual type `Action m0 [Database.MongoDB.Document]'
I'm sorry to post a "Send me the codes plz" question, but I'm at loss: where am I going wrong, and how do I make this work?

Answer 1

Here is your function annotated with type signatures. I think this makes it
pretty clear where the problem lies.
testSplice :: Splice AppHandler
testSplice = do
record <- liftIO $ do
pipe <- runIOE $ connect (host "127.0.0.1") -- :: IO Pipe
results <- access pipe master "db" (find $ select [] "coll")
-- ^ :: IO (Either Failure Cursor)
close pipe -- :: IO ()
rest result -- :: Action m [Document]
return $ [TextNode $ T.pack $ show $ records]
Everything inside the "liftIO $ do" block must be an IO action. The last line
"rest result" is not. One solution is to prepend that line with 'access pipe
master "db"' just like you've done with find. Another solution is to avoid
calling "access pipe..." twice and replace the find line with the following:
result <- access pipe master "db" (find (select [] "coll") >>= rest)
Then replace the "rest result" line with "return result"
What Daniel says about the find line not needing liftIO is correct, but in
this case it doesn't matter because IO has a MonadIO instance. So it's probably just as easy to keep all the liftIO stuff in one block.

Answer 2

I am not a MongoDB expert, so I'm not 100% sure (and I can't test it), but I suspect that you've got your liftIO in the wrong place. We have liftIO :: MonadIO m => IO a -> m a, so we should apply liftIO to actions that are actually IO, but which we want to be something bigger than IO. I suspect that access is a function with a bigger-than-IO return type. Assuming runIOE, close, and rest all actually have IO return types, we'd then do something like this:
testSplice = do
pipe <- liftIO . runIOE $ connect (host "127.0.0.1")
results <- access pipe master "db" (find $ select [] "coll") -- note: no liftIO on this one because it's presumably already lifted
liftIO $ close pipe
record <- liftIO $ rest result
return [TextNode . T.pack . show $ records]
If some of those actions actually are not IO things, then you can drop the liftIO from those ones.
As you observed, this can be cleaned up a bit: any adjacent lines that start with liftIO can be coalesced. So if the above turns out to be the right places for liftIOs, then it could also be written as:
testSplice = do
pipe <- liftIO . runIOE $ connect (host "127.0.0.1")
results <- access pipe master "db" (find $ select [] "coll")
liftIO $ do
close pipe
record <- rest result
return [TextNode . T.pack . show $ records]
(The last one there is OK because return = liftIO . return for any sane implementation of liftIO.)