Haskell requires an explicit type for operations involving input and output.
This way it makes a problem explicit, that exists in every language:
input and output definitions can have so many effects, that the type signature says more or less that almost everything must be expected.
It is hard to test them, because they can in principle depend on every state of the real world.
Thus in order to maintain modularity you should avoid I/O wherever possible.
It is too tempting to disguise the use of I/O with
unsafePerformIO, but we want to present some clean techniques to avoid I/O.
You can avoid a series of output functions by constructing a complex data structure with non-I/O code and output it with one output function.
-- import Control.Monad (replicateM_) replicateM_ 10 (putStr "foo")
you can also create the complete string and output it with one call of
putStr (concat $ replicate 10 "foo")
do h <- openFile "foo" WriteMode replicateM_ 10 (hPutStr h "bar") hClose h
can be shortened to
writeFile "foo" (concat $ replicate 10 "bar")
which also ensures proper closing of the handle
h in case of failure.
Since you have now an expression for the complete result as string, you have a simple object that can be re-used in other contexts. For example, you can also easily compute the length of the written string using
length without bothering the file system, again.
If the only reason that you need I/O is to output information (e.g. logging, collecting statistics), a Writer monad might do the job. This technique works just fine with lazy construction, especially if the lazy object that you need to create is a Monoid.
An inefficient example of logging:
logText :: (MonadWriter String m) => String -> m () logText text = tell (text ++ "\n") do logText "Before operation A" opA logText "After operation A"
(This is "inefficient", because
tell "writes" to the "end" of the log using
code for lists (i.e.
(++)) is O(n), where n is the length of the left-hand list (i.e. the log). In other words, the bigger the log gets, the slower logging becomes. To avoid this, you should generally use a type that has O(1)
mappend, such as
fold the complete log (using Foldable) afterwards if you need to.)
If you want to maintain a running state, it is tempting to use
But this is not necessary, since there is the comfortable
State monad and its transformer counterpart.
Another example is random number generation. In cases where no real random numbers are required, but only arbitrary numbers, you do not need access to the outside world. You can simply use a pseudo random number generator with an explicit state. This state can be hidden in a State monad.
Example: A function which computes a random value with respect to a custom distribution (
distInv is the inverse of the distribution function) can be defined using I/O
randomDist :: (Random a, Num a) => (a -> a) -> IO a randomDist distInv = liftM distInv (randomRIO (0,1))
You don't need the state of the whole world just for remembering the state of a random number generator, instead you can use something similar to this:
randomDist :: (RandomGen g, Random a, Num a) => (a -> a) -> State g a randomDist distInv = liftM distInv (State (randomR (0,1)))
You can get actual values by running the
State as follows:
evalState (randomDist distInv) (mkStdGen an_arbitrary_seed)
The monadic ST type
In some cases a state monad is simply not efficient enough.
Say the state is an array and the update operations are modification of single array elements.
For this kind of application the State Thread monad
ST was invented.
STRef as replacement for
STArray as replacement for
STUArray as replacement for
and you can define new operations in
ST, but then you need to resort to unsafe operations by using the
You can escape from
ST to non-monadic code in a safe, and in many cases efficient, way.
Applicative functor style
Say you have written the function
translate :: String -> IO String translate word = do dict <- readDictionary "english-german.dict" return (Map.findWithDefault word word dict)
You can only call this function within the I/O monad, and it is not very efficient either, since for every translation the dictionary must be read from disk. You can rewrite this function in a way that it generates a non-monadic function that can be used anywhere.
makeTranslator :: IO (String -> String) makeTranslator = do dict <- readDictionary "english-german.dict" return (\word -> Map.findWithDefault word word dict) main :: IO () main = do translate <- makeTranslator putStr (unlines (map translate ["foo", "bar"]))
I call this Applicative Functor style because you can use the application operator from
makeTranslator <*> getLine
Custom monad type class
If you only use a small set of I/O operations in otherwise non-I/O code you may define a custom monad type class which implements just these functions. You can then implement these functions based on I/O for the application and without I/O for the test suite.
As an example consider the function
localeTextIO :: String -> IO String
which converts an English phrase to the currently configured user language of the system.
You can abstract the
IO type away using
class Monad m => Locale m where localeText :: String -> m String instance Locale IO where localeText = localeTextIO instance Locale Identity where localeText = Identity
where the first instance can be used for the application and the second one for "dry" tests.
For more sophisticated tests, you may load a dictionary into a
Map and use this for translation.
newtype Interpreter a = Interpreter (Reader (Map String String) a) instance Locale Interpreter where localeText text = Interpreter $ fmap (Map.findWithDefault text text) ask
The last resort
The method of last resort is
unsafePerformIO. When you apply it, think about how to reduce its use and how you can encapsulate it in a library with a well chosen interface. Since
unsafePerformIO makes I/O operations look like non-I/O functions, they should also behave like non-I/O functions e.g. file access must not be hidden by using
unsafePerformIO, whereas careful memory manipulation may be safe – see for instance the