Question

I want to receive a string, convert it to a list and write every element of the list into a TChan. For every string received I want to fork a new process.

My problem is that I get errors related to IO when I try to compile this:

Couldn't match expected type `IO ()' with actual type `[()]'

or

Couldn't match expected type `IO ()' with actual type `[IO ()]'

Whilst I completely understand the error and know where it originates from ( – at least the first error – ) I am now out of ideas how I could split IO an computation in my example and still achieve what I try to do.

write2TChan msg mtch = do
        let mymessages = words msg
        map (\x -> atomically $ writeTChan mtch x) mymessages
        return ()

main = withSocketsDo $ do
        s <- socket AF_INET Datagram defaultProtocol
        bindAddr <- inet_addr host
        bindSocket s (SockAddrInet port bindAddr)
        mtch <- newTChanIO
        let forever socket hosts = do
                (msg, host) <- receiveMessage socket
                return ()
                return (forkIO $ write2TChan msg mtch)
                --forkIO $ write2TChan msg mtch
                --tried w return () and above, same problem
                forever socket hosts
        forever s []
        sClose s

Answer 1

map has the type map :: (a -> b) -> [a] -> [b], so it always returns a list. However, every statement in a do block in the IO monad must have type IO a for some a.

You want the related function mapM :: Monad m => (a -> m b) -> [a] -> m [b] which does the same thing in a monad. Since you want to ignore the result, we can use the variant mapM_ :: Monad m => (a -> m b) -> [a] -> m ().

write2TChan msg mtch = do
    let mymessages = words msg
    mapM_ (\x -> atomically $ writeTChan mtch x) mymessages

For your other function you should be able to use forkIO directly. Wrapping it in return makes no sense at all, as that would make the type IO (IO a), i.e. an action returning an action. Also, return () is a no-op when it’s not the last statement in a do block, so you don’t need that.

This should work

let forever socket hosts = do
         (msg, host) <- receiveMessage socket
         forkIO $ write2TChan msg mtch
         forever socket hosts

though, the hosts argument is currently always [], so unless you plan to do something about that, you can get rid of that, too. Also, I would avoid the name forever since there is already a commonly used function in Control.Monad with that name.