This site is updated infrequently. For up-to-date information, please visit the new OCaml website at ocaml.org.

[Caml-list] Are map and iter guaranteed to be called in forwards order?
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: -- (:) From: John Prevost Subject: Re: [Caml-list] Are map and iter guaranteed to be called in forwards order?
```On Tue, 17 Aug 2004 15:56:53 +0100, Richard Jones <rich@annexia.org> wrote:
> This came up because I wanted a sensible way to number a list of
> items.  The obvious imperative approach is:
>
>   # let items = ['a';'c';'e';'g';'i'];;
>   val items : char list = ['a'; 'c'; 'e'; 'g'; 'i']
>   # let i = ref 0;;
>   val i : int ref = {contents = 0}
>   # let items = List.map (fun item -> let n = !i in incr i; n, item) items;;
>   val items : (int * char) list =
>     [(0, 'a'); (1, 'c'); (2, 'e'); (3, 'g'); (4, 'i')]
>
> The functional approach is comparatively long-winded: you have to
> effectively write your own loop explicitly, and the obvious way to
> write it isn't tail recursive, so you have to do it with accumulators.
>
> It'd be nicer to have a library HOF to do this.

let number l =
let _, l = List.fold_left (fun (n, l) i -> (n+1, (n, i)::l)) (0, []) l in
List.rev l

You could even do fold with side effects if you really want to:

let number' l =
let i = ref 0 in
let l = List.fold_left (fun l x -> let n = !i in incr i; (n, x) :: l) [] l in
List.rev l

Or define your own version of map, that you have explicitly written to
be based on fold_left, which allows you to be sure that it will always
work the same way:

let folding_map f l =
let l = List.fold_left (fun l x -> (f x)::l) [] l in
List.rev l

John.

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

```