Hi! I would like to make an one-directional inter-process communication in a way that one process is printing out read-compatible Haskell data types and Haskell program is reading them from a pipe. I would like to make a function which would return Nothing if there is no data type in a pipe or Just last data type there was in a pipe (discarding all before). So it should behave in a non-blocking way. In an attempt I made this: getLastMyData :: MyState (Maybe MyData) getLastMyData = do p <- gets process case p of Nothing -> fail "No process" Just (MyProcess processOut processPid processBuffer) -> do processRunning <- io $ getProcessExitCode processPid case processRunning of Just _ -> processExited _ -> do ret <- io $ tryJust (guard . isEOFError) $ slurpInput processOut processBuffer case ret of Left _ -> processExited -- EOF Right currentBuffer -> do let (datalist, currentBuffer') = readData currentBuffer modify (\s -> s { process = Just (MyProcess processOut processPid currentBuffer') }) if null datalist then return Nothing else return $ Just $ head datalist -- MyData is stored in the reverse order so head is the last MyData from the process slurpInput :: Handle -> String -> IO String slurpInput h buffer = do ready <- hReady h if not ready then return buffer else do char <- hGetChar h slurpInput h (buffer ++ [char]) readData :: String -> ([MyData], String) readData buffer = readData' [] buffer where readData' datalist [] = (datalist, []) readData' datalist buf = case reads buf of [(x, rest)] -> readData' ((head x):datalist) rest -- x is a list and currently it has only one element [] -> if length buf > 5 * maxMyDataDescLength then error "Invalid data from process" else (datalist, buf) -- we probably do not have enough data to read MyData properly _ -> error "Ambiguous parse from process" (I have cleaned a code somewhat, I hope I have not introduced any errors. MyData is encapsulated in a list when printed from a process, this is why is there "head".) The problem is that I do not like this approach. And it does not look nice. For example I am reading byte per byte and appending it to the end. Then the problem is that if process is sending garbage faster then Haskell can consume it Haskell stays in slurpInput function and never gets to readData where it would found out that there is garbage coming in. I could use hGetBufNonBlocking? But it would still not solve garbage problem. So is there some better way to do it? Mitar