On Nov 17, 2003, at 11:37, chris.danx wrote:

> let prodAdd x =
>    let value = ref x in
>       fun y -> !value + y;;

	This is very similar to

let prodAdd x y = x + y;;

	The only difference is that I'm making a reference with the value of x.

# let prodAdd x = let value = ref x in fun y -> !value + y;;
val prodAdd : int -> int -> int = <fun>
# let prodAdd2 x y = x + y;;
val prodAdd2 : int -> int -> int = <fun>
# prodAdd 1 2;;
- : int = 3
# prodAdd2 1 2;;
- : int = 3
# prodAdd 1;;
- : int -> int = <fun>
# prodAdd2 1;;
- : int -> int = <fun>


> Now I want to do a function that takes a ref to a list and returns a 
> function that adds items to the list and produce a function that 
> returns another that returns the list.  How do I do that?
>
> let prod_list_acc a =
>   fun x -> a := x :: !a; true;;
>
> let return_acc a =
>   fun () -> !a;;
>
> but that gives a "unit -> int list" =.  How do you get a copy of the 
> list values?
>
>
> This might seem like a crazy thing to do but I am toying with an idea 
> relating to a paper I read on traits.  Instead of having classes at 
> all you can just have traits, closures and mutable values.

	That's not a very functional style.  It does seem to work for me with 
the following syntax, though:

  # let list_acc a x = a := x :: !a; ();;
val list_acc : 'a list ref -> 'a -> unit = <fun>
# let return_list a = !a;;
val return_list : 'a ref -> 'a = <fun>
# return_list a;;
- : int list = [1; 2; 3; 4; 5]
# list_acc a 6;;
- : unit = ()
# return_list a;;
- : int list = [6; 1; 2; 3; 4; 5]


-- 
Dustin Sallings

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners