Question

I have declared the following

type KEY = (IPv4, Integer)
type TPSQ = TVar (PSQ.PSQ KEY POSIXTime)
type TMap = TVar (Map.Map KEY [String])

data Qcfg = Qcfg { qthresh :: Int, tdelay :: Rational, cwpsq :: TPSQ, cwmap :: TMap, cw
chan :: TChan String } deriving (Show)

and would like this to be serializable in a sense that Qcfg can either be written to disk or be sent over the network. When I compile this I get the error

No instances for (Show TMap, Show TPSQ, Show (TChan String))
      arising from the 'deriving' clause of a data type declaration
    Possible fix:
      add instance declarations for
      (Show TMap, Show TPSQ, Show (TChan String))
      or use a standalone 'deriving instance' declaration,
           so you can specify the instance context yourself
    When deriving the instance for (Show Qcfg)

I am now not quite sure whether there is a chance at all to serialize my TChan although all individual nodes in it are members of the show class.

For TMap and TPSQ I wonder whether there are ways to show the values in the TVar directly (because it does not get changed, so there should no need to lock it) without having to declare an instance that does a readTVar ?

Answer 1

I understood your comments to mean that you want to serialize the contents of the TVar and not the TVar itself.

There is only one way to extract the value from a TVar, and that’s readTVar:

readTVar :: TVar a -> STM a

… which you can do in the IO monad using atomically:

atomically . readTVar :: TVar a -> IO a

TChan is more tricky, though, since you can’t inspect the contents without flushing out the entire TChan. This is doable, even if wastefully, by inspecting the entire contents as a single STM action and then reinserting them all. If this is what you choose to do, it would also eventually require being run in the IO monad.

This means you won’t be able to derive a Show instance for it, since Show expects a pure computation that converts it to a String, and not one residing in the IO monad.

However, there’s no reason you have to use the Show class. You can just define a custom function to serialize your data type in the IO monad. Also, it’s generally not advisable to use Show for serialization purposes since:

• Some of your data types (like PSQ) have no Read instance
• It’s a pain in the butt to define Read instances in general
• String representations are very space-inefficient

So I would recommend you use a proper serialization library like binary or cereal to do serialization and deserialization. These convert data types to a binary representation, and they make it very easy to define encoders and decoders.

However, even those libraries only accept instances for pure conversions and not operations in the IO monad, so what you must do is factor your serialization into a two-step process:

1. Extract the contents of your TVars in the IO monad.
2. Serialize the contents (along with the rest of your data-type) using cereal/binary.

There is still one last caveat, which is that not all of your data types have Binary instances (assuming we use the binary package), but fortunately lists do have a Binary instance, so a convenient work-around is to just convert your data type to a list (using toList and serialize the list. Then, when you deserialize the list, you use fromList to recover your original type.

So the following function will do all of that (using binary):

serializeQcfg file (Qcfg qthresh tdelay cwpsq cwmap cwchan) = do
    -- Step 1: Extract contents of concurrency variables
    psq    <- atomically $ readTVar cwpsq
    myMap  <- atomically $ readTVar cwmap
    myChan <- atomically $ entireTChan cwchan
    -- Step 2: Encode the extracted data
    encodeFile file (qthresh, tdelay, toList psq, myMap, myChan)

Edit: Actually, it’s probably better to combine all the atomic transactions into a single transaction as Daniel pointed out, so you would actually do:

serializeQcfg file (Qcfg qthresh tdelay cwpsq cwmap cwchan) = do
    -- Step 1: Extract contents of concurrency variables
    (psq, myMap, myChain) <- atomically $ (,,) <$> readTVar cwpsq
                                               <*> readTVar cwmap
                                               <*> entireTChan cwchan
    -- Step 2: Encode the extracted data
    encodeFile file (qthresh, tdelay, toList psq, myMap, myChan)

I left out the implementation of entireTChan, which would basically flush the TChan to inspect the entire contents and then reload it again, but its type signature would be something like:

entireTChan :: TChan a -> STM [a]

I also left out the deserialization implementation, but I think if you understand the above example and take the time to learn how to use the binary or cereal packages you should be able to figure it out easily enough.