f.hs

data Event = Event { eventTag :: Int
                   , eventPayload :: Pay }

data BackendWithChan = BackendWithChan 
  { bwcBackend :: Backend
  , bwcBroadcast :: TChan Event
  }
  
data Backend = Backend { backendTag :: Int }

makeBackends :: [Backend] -> STM [BackendWithChan]
makeBackends bs = do
  writer <- newBroadcastTChan
  traverse (BackendWithChan b <$> dupChan writer) bs
  
awaitEvent :: BackendWithChan -> STM Event
awaitEvent b = do e <- readTVar (bwcBroadcast b)
               if eventTag e == backendTag (bwcBackend b)
               then awaitEvent b
               else pure e
               
tryAwaitEvent :: BackendWithChan -> STM (Maybe Event)
tryAwaitEvent b = do e <- readTVar (bwcBroadcast b)
                     case e of
                       Nothing -> pure Nothing
                       Just e | eventTag e == backendTag (bwcBackend b)
                              -> tryAwaitEvent b
                              | otherwise
                              -> pure (Just e)
                              
tryAwaitEventIO :: BackendWithChan -> IO (Maybe Event)
tryAwaitEventIO = atomically . tryAwaitEvent

runBackend :: BackendWithChan -> IO ()
runBackend b =  do whatever...


run :: [Backend] -> IO ()
run bs = do bsc <- atomically (makeBackends bs)
            mapConcurrently runBackend bsc