Difference between revisions of "Avoiding IO"
(randomIO) |
(ST monad) |
||
Line 73: | Line 73: | ||
evalState (randomDist distInv) (mkStdGen an_arbitrary_seed) |
evalState (randomDist distInv) (mkStdGen an_arbitrary_seed) |
||
</haskell> |
</haskell> |
||
− | |||
== ST monad == |
== ST monad == |
||
+ | In some cases a state monad is simply not efficient enough. |
||
− | STRef instead of IORef, STArray instead of IOArray |
||
+ | Say the state is an array and the update operations are modification of single array elements. |
||
+ | For this kind of application the [[Monad/ST|State Thread monad]] <hask>ST</hask> was invented. |
||
+ | It provides <hask>STRef</hask> as replacement for <hask>IORef</hask>, |
||
+ | <hask>STArray</hask> as replacement for <hask>IOArray</hask>, |
||
+ | <hask>STUArray</hask> as replacement for <hask>IOUArray</hask>, |
||
+ | and you can define new operations in ST, but then you need to resort to unsafe operations. |
||
+ | You can escape from ST to non-monadic code in a safe, and in many cases efficient, way. |
||
== Custom type class == |
== Custom type class == |
||
Line 83: | Line 89: | ||
example getText |
example getText |
||
+ | |||
+ | == Last resort == |
||
+ | |||
+ | The method of last resort is <hask>unsafePerformIO</hask>. |
||
+ | 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. |
||
+ | You may define new operations in the <hask>ST</hask> monad using <hask>unsafeIOToST</hask>. |
||
[[Category:Monad]] |
[[Category:Monad]] |
||
[[Category:Idioms]] |
[[Category:Idioms]] |
||
− | [[Category:Style]] |
+ | [[Category:Style]] |
Revision as of 16:46, 25 December 2008
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 functions 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 IO whereever possible.
It is too tempting to get rid of IO by unsafePerformIO
,
but we want to present some clean techniques to avoid IO.
Lazy construction
You can avoid a series of output functions by constructing a complex data structure with non-IO code and output it with one output function.
Instead of
-- import Control.Monad (replicateM_)
replicateM_ 10 (putStr "foo")
you can also create the complete string and output it with one call of putStr
:
putStr (concat $ replicate 10 "foo")
Similarly,
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.
E.g. you can also easily compute the length of the written string using length
without bothering the file system, again.
State monad
If you want to maintain a running state, it is tempting to use IORef
.
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 via IO
randomDist :: (Random a, Num a) => (a -> a) -> IO a
randomDist distInv = liftM distInv (randomRIO (0,1))
but there is no need to do so. You don't need the state of the whole world just for remembering the state of a random number generator. What about
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)
ST monad
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.
It provides STRef
as replacement for IORef
,
STArray
as replacement for IOArray
,
STUArray
as replacement for IOUArray
,
and you can define new operations in ST, but then you need to resort to unsafe operations.
You can escape from ST to non-monadic code in a safe, and in many cases efficient, way.
Custom type class
example getText
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.
You may define new operations in the ST
monad using unsafeIOToST
.