Local references in Ocaml vs. state in Haskell

Local references in Ocaml vs. state in Haskell

[Andrej Bauer]

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

Re: [Caml-list] Local references in Ocaml vs. state in Haskell

[Jeff Polakow]

[-- Attachment #1: Type: text/plain, Size: 2305 bytes --]

Hello,

  The ocaml code can be directly translatedto Haskell using the ST monad 
and STRef.

-Jeff


caml-list-bounces@yquem.inria.fr wrote on 11/23/2007 05:16:00 AM:

> 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
> 
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs


---

This e-mail may contain confidential and/or privileged information. If you 
are not the intended recipient (or have received this e-mail in error) 
please notify the sender immediately and destroy this e-mail. Any 
unauthorized copying, disclosure or distribution of the material in this 
e-mail is strictly forbidden.

[-- Attachment #2: Type: text/html, Size: 3072 bytes --]