[Haskell-cafe] IO and State (was Re: [Haskell] Re: Global Variables
and IO initializers)
Iavor S. Diatchki
diatchki at cse.ogi.edu
Mon Nov 8 13:38:54 EST 2004
Just wanted to point out that the suggested idea is not quite correct.
(well that has to be quantiifed a bit, see bellow)
Krasimir Angelov wrote:
>--- Ben Rudiak-Gould
><Benjamin.Rudiak-Gould at cl.cam.ac.uk> wrote:
>>This is solved by merging the IO and ST monads,
>>something that ought to
>>be done anyway:
>> type IO = ST RealWorld
>> type IORef a = Ref RealWorld a
>> type STRef s a = Ref s a
It is not (should not be?) the case that IO = ST RealWord, as IO is not
a state monad as we understand it.
In a state monad, the changes to the state are all in the program, i.e.
one can always
point to the part of the program that modified the state.
On the other hand, the "state" of the RealWorld can change on its own,
without anything in the program affecting it.
I guess this is similar to "volatile" state in C.
For example, one might expect the following rule in a state monad:
do x <- readSTRef r
y <- readSTRef r
f x y
do x <- readSTRef r
f x x
But this is not true for the IO monad, as for example reading a file
twice does not guarantee
that you will get the same result, even if no part of the program ever
wrote to the file.
Now the above law already doesn't hold when all GHC extensions are used,
as when concurrency is present we cannot assume that nobody modified the
As a result all pointers in GHC probably behave as if they were
"volatile", which is not very nice.
I think that inherently there are two concepts here, and I see no point
in mixing them
(even though they are already a bit mixed up, because of stToIO).
The one is the usual sequential state that we know and love (and I think
we use that a lot of the time).
In the sequential state the above optimization is one of the laws
specifying the monad.
The other concept is that of "volatile" or concurrent state, and then
the law doesn't hold.
The two monads have a very similar inetrafce (reading and wrinting
pointers, and creating new pointers)
but the laws that the operations satisfy are different.
More information about the Haskell-Cafe