I have some programs written in ocaml that use references. I wanted to 
translate them to Haskell, but since I am not an active Haskell user, I 
got stuck with a very simple problem, namely, that the state monad in 
Haskell provides _global_ references while ocaml has _local_ references.

Suppose in ocaml I have this:

(* Does a functional [f] look at its argument [a]? *)
let touched f a =
   let flag = ref false in
   let _ = f (fun n -> flag := true; a n) in
     !flag

"touched f a" evaluates "f a" and records the fact that f actually 
evaluated a at some argument. Note that flag is a local reference, so f 
does not have access to it.

Using a global flag does not work:

let flag = ref false

let touched' f a =
   flag := false ;
   let _ = f (fun n -> flag := true; a n) in
     !flag

Now we can write an f which touches its argument but fools touched' by 
reversing the value of flag.

let f a =
   let y = a 42 in
     touched := false ; y

If I try to use the State monad I will get a global reference threaded 
thrugh the computation, and f will have access to it. I want a local 
reference that is inaccessible outside its lexical scope. I am probably 
missing something obvious about Haskell.

I am hoping that even though this is a question about Haskell, you won't 
mind, as it gives everyone on this list an opportunity to show how ocaml 
is superior to Haskell. Just kidding :-)

Andrej