On Mon, 17 Nov 2003, chris.danx wrote:

> Hi,
> 
> I was toying with ocaml just now and have successfully written a 
> function that takes and int that produces a function that takes an int 
> to add to the original.
> 
> let prodAdd x =
>     let value = ref x in
>        fun y -> !value + y;;

Since you're not setting the reference, why have one?  Instead, try:

let prodAdd x = fun y -> x + y

But we can do it simpler than that:

let prodAdd x y = x + y

And use partial function application.  (prodAdd 4) returns a function 
which adds 4 to whatever int parameter passed to it.

> 
> 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?

Now you're setting the reference.  But prod_list_acc and return_acc need 
to share the reference.

Now, I for one, hate globals.  This is the result of programming for years 
in C.  What I would do is write a function which returns a tuple of two 
functions, and accumlator function and a current list function, like:

let make_listacc () =
	let r: int list ref = ref [] in
	let acc x = r := x :: !r
	and lst () = !r
	in acc, lst
;;

This allows you to have multiple different lists being constructed 
independently.  Note, the above code is actually more generic than it 
looks- I had to add an explicit type statement to make it "come out 
correct".  Without the explicit type information:

let make_listacc () =
        let r = ref [] in
        let acc x = r := x :: !r
        and lst () = !r
        in acc, lst
;;

The function is both clearer than the original, and creates lists of any 
type, not just ints.  If you hear me bitching about C++ and Java making 
generics "special and extraordinary", this is a classic example of what 
I'm kvetching about.

You'd use make_listacc like:

	let my_acc, my_list = make_listacc() in
	my_acc 3;
	my_acc 4;
	my_acc 5;
	my_list ()
	;;

The above code returns [5;4;3] (note, the list is built backward!).

The most common way to access members of a list is to use what is called 
"list comprehensions".  Don't let the names fool you- these are just 
functions that walk the list and do something on every element of the 
list.  Look at List.iter and List.fold_left.  So let's say I want to take 
a list of ints and sum them.  I could simply do:
	List.fold_left (fun x y -> x + y) 0 lst

Note that + is just a function, so I could just as easily have done:
	List.fold_left (+) 0 lst
to do the same thing.

The second most common way to access members of a list is to write a short 
recursive function.  Say I wanted to know if the list contained a given 
number.  I might write:
	let rec has_num x = function
		| [] -> false
		| h :: t -> if (h == x) then true else has_num x t
	;;

If you want to access specific members of a list (other than the head), I
wouldn't recommend using a list, but instead some other datastructure (an
array or hash table being the obvious choices).


-- 
"Usenet is like a herd of performing elephants with diarrhea -- massive,
difficult to redirect, awe-inspiring, entertaining, and a source of
mind-boggling amounts of excrement when you least expect it."
                                - Gene Spafford 
Brian


-------------------
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