Question

I would like to call a UDP send function within an STM transaction so that I can avoid code like below where m’ is read (and could be updated by an other thread) before the values are eventually sent & where two consecutive where clauses make me look quite “helpless”.

sendRecv s newmsgs q m = do
     m' <- atomically $ readTVar m
     time <- getPOSIXTime
     result <- appendMsg newmsgs key m
     when (result > 0) (atomically $ do 
                           mT <- readTVar m
                           qT <- readTVar q
                           --let Just messages = Map.lookup key mT in sendq s (B.pack $ unwords messages) "192.168.1.1" 4711 
                           let mT' = Map.delete key mT
                               qT' = PSQ.delete key qT
                           writeTVar q (PSQ.insert key time qT')
                           writeTVar m (Map.insert key [newmsgs] mT'))
     when (result > 0) (let Just messages = Map.lookup key m' in sendq s (B.pack $ unwords messages) "192.168.1.1" 4711) 

sendq :: Socket -> B.ByteString -> String -> PortNumber -> IO ()
sendq s datastring host port = do
      hostAddr <- inet_addr host
      sendAllTo s datastring (SockAddrInet port hostAddr)
      return ()

I thought that by invoking TVars with newTVarIO and using import System.IO.Unsafe I could eventually use unsafePerformIO somewhere and call my sendq function (that returns IO() ) from within the transaction.

However, I do not find where this “somewhere” is? Is it at the creation of the TVar? Is it instead of atomically $ do? Do I understand the sense an applicability of unsafePerformIO wrong?

Answer 1

IO cannot be done from inside an STM block, because general IO cannot be undone. If you want to do some IO, you must schedule it in the STM block, but do it outside. For example:

foo tvar = do
    scheduledAction <- atomically $ do
        v <- readTVar tvar
        when v retry
        return (sendSomethingOnASocket "okay, we're done here")
    scheduledAction