How does one transform a data type into BSON in Haskell?

Question

I've been trying to understand how to transform a Data type into a Document with Haskell's Data.Bson.Mapping package, however, I couldn't figure it out and the example in the docs didn't help much either.

How should I resolve this problem? No questions regarding this seem to have been posted yet. I'll attach relevant code below, so you may be able to understand where I'm coming from.

{-# LANGUAGE TemplateHaskell #-}

module Main where
import Database.MongoDB.Connection  (host, connect)
import Database.MongoDB.Query       (access, master, insertMany)
import Data.Data                    (Typeable)
import Data.Bson.Mapping

data Item a = Item { content :: a
                   , checked :: Bool
                   } deriving (Eq, Show, Typeable)

What I've tried so far

selectFields, but I don't know how to change the Expression (Q Exp) into a Document
Implementing deriveBson, but I got the same error as with the example from the Docs

Please note, I'm still fairly new to Haskell and I have spent 2 hours looking for a solution, but just couldn't figure it out.

Thank you.

Does the deriveBson work if your Item is not parametric in 'a'? Also, what error are you getting? — Marc Talbot, Mar 13 '18 at 17:00
`bson-mapping`'s Template Haskell macros look a bit strange – any reason you prefer that package over `bson-generic` or one of the converters to Aeson? — leftaroundabout, Mar 13 '18 at 17:38
@leftaroundabout I just tried to go with the "native" Data.Bson package! — Lukas Süsslin, Mar 13 '18 at 22:56
@MarcTalbot I tried it out, but it didn't resolve it. The "deriving" of TemplateHaskell doesn't work — Lukas Süsslin, Mar 13 '18 at 22:56

epsilonhalbe · Accepted Answer · 2018-03-13T23:08:14.867

You speak of an error but don't post the error itself so I cannot help with that - but serializing your data type should be fairly straightforward

data Item a = Item { content :: a
                   , checked :: Bool
                   } deriving (Eq, Show, Typeable)

instance (Bson a) => Bson (Item a) where
  toBson (Item cont check) = ["content" := Doc (toBson cont)
                             ,"checked" := Bool check]
  fromBson d = do cont  <- "content" `lookup` d
                  check <- "checked" `lookup` d
                  pure $ Item cont check

toBson has to create a Document which is just a type synonym for [Field] where Field is just a Label associated with a tagged value. Of course we have to require a to implement serialization and de-serialization in order to make Item an instance of Bson.

For the de-serialization I chose the lookup function which gives back a monadic value i.e. the value if found and a way to fail if not. E.g. if our monad is Maybe then it would give back a Nothing if not found and a Just x otherwise, for IO we would get a run-time error (something we want to avoid). so when calling toBson ... make sure you execute it in a sane monad like Maybe _ or Either String _.

Test it with

toBson ["no-content":=Int64 1, "checked":= Bool True] :: Maybe (Item Int)
toBson ["content":=Int64 1, "unchecked":= Bool True] :: Either String (Item Int)

If you want to skip an implementation by hand - you need to show me the error, I'd be happy to help you with what went wrong.

ps: code is not compiled - don't have a ghc with me right now — epsilonhalbe, Mar 13 '18 at 17:36
thank you very much, this is a very amazing explanation and solution! You put a lot of thought in this. I appreciate the effort ☺️ — Lukas Süsslin, Mar 13 '18 at 23:39

How does one transform a data type into BSON in Haskell?

1 Answers1