Question

Haskell is a pure functional language, which means Haskell functions have no side affects. I/O is implemented using monads that represent chunks of I/O computation.

Is it possible to test the return value of Haskell I/O functions?

Let’s say we have a simple ‘hello world’ program:

main :: IO ()
main = putStr "Hello world!"

Is it possible for me to create a test harness that can run main and check that the I/O monad it returns the correct ‘value’? Or does the fact that monads are supposed to be opaque blocks of computation prevent me from doing this?

Note, I’m not trying to compare the return values of I/O actions. I want to compare the return value of I/O functions – the I/O monad itself.

Since in Haskell I/O is returned rather than executed, I was hoping to examine the chunk of I/O computation returned by an I/O function and see whether or not it was correct. I thought this could allow I/O functions to be unit tested in a way they cannot in imperative languages where I/O is a side-effect.

Answer 1

The way I would do this would be to create my own IO monad which contained the actions that I wanted to model. The I would run the monadic computations I want to compare within my monad and compare the effects they had.

Let’s take an example. Suppose I want to model printing stuff. Then I can model my IO monad like this:

data IO a where
  Return  :: a -> IO a
  Bind    :: IO a -> (a -> IO b) -> IO b
  PutChar :: Char -> IO ()

instance Monad IO where
  return a = Return a
  Return a  >>= f = f a
  Bind m k  >>= f = Bind m (k >=> f)
  PutChar c >>= f = Bind (PutChar c) f

putChar c = PutChar c

runIO :: IO a -> (a,String)
runIO (Return a) = (a,"")
runIO (Bind m f) = (b,s1++s2)
  where (a,s1) = runIO m
        (b,s2) = runIO (f a)
runIO (PutChar c) = ((),[c])

Here’s how I would compare the effects:

compareIO :: IO a -> IO b -> Bool
compareIO ioA ioB = outA == outB
  where ioA = runIO ioA ioB

There are things that this kind of model doesn’t handle. Input, for instance, is tricky. But I hope that it will fit your usecase. I should also mention that there are more clever and efficient ways of modelling effects in this way. I’ve chosen this particular way because I think it’s the easiest one to understand.

For more information I can recommend the paper “Beauty in the Beast: A Functional Semantics for the Awkward Squad” which can be found on this page along with some other relevant papers.