For this message I'll classify functions on "levels" based on how many
nested parenthesis are needed to represent their type.

Functions of level 0 (e.g. int -> int, char -> int -> int, ...) are
the most used in programming. In widespread languages like C#, Java
and C++ they are almost the only kind of functions used.

Functions of level 1 (e.g. ('a -> 'b) -> ('b -> 'c) -> ('a -> 'c)) are
used a lot when programming in a functional language. They are also
the ones that appear in examples and tutorials written for imperative
programmers. This category includes fold, iter, map, composition.

However a language like OCaml allows N to go up as much as you want.
My question is: are there functions of level >= 2 used in practice
(e.g. (('a -> 'b -> 'a) -> 'a -> 'b list -> 'a) -> 'c)? If so, are
there any typical ones that appear in many applications (maybe not as
widespread like map & company but at least of comparable usefulness)?
One example of a level 2 function (stolen from a recent post by Jon
Harrop) is this:
  let sum fold = fold (+);;

regards,
radu

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