Re: [Caml-list] List.fold_left vs. Hashtbl.fold

["Daniel Bünzli" <daniel.buenzli@erratique.ch>]

Le vendredi, 30 novembre 2012 à 17:00, Gabriel Scherer a écrit :
> I don't know. "function application is just space" is indeed a
> convenient syntax to emulate other syntaxes (for example embed a
> concatenative language through cunning continuation-passing-style),

My concern is not really about the syntax.

> but that doesn't need to go away with non-currified functions, which
> is about applying all arguments, not necessarily forcing a tupled
> syntax.

That's the point, currying allows you to build a function incrementally with things happening between each applied argument.  

This is for example very useful to meta-program other languages from OCaml (using the abstraction mechanisms and variable binders of OCaml itself). It may not be very clear (the whole program is not here, if you are interested I can mail you the whole example), but with the combinators given at the end of this message, I'm able to gradually construct a program representing a function in another language, with an arbitrary number of arguments, compile it, and then get it as regular OCaml function (Program.as_fun) that uses OCaml gound types and that can be passed around completely hiding that the function may actually not be executed by OCaml at all.

Currying gives you glue, I'm not sure you could do these kind of things without it. If you can't then currying is not overrated to me. See also http://mlton.org/Fold

Best,

Daniel

type 'a exp (* expressions constructed with combinators *)

module Program : sig
  type 'a t  
  type ('a, 'b, 'c) stage (* b is the type of the constructed function *)

  (* Note. The types enforces that only caml functions from 'a exp(s) to
   'a exp will be accepted for compilation into a program. *)

  val retb : ('a exp -> 'b) -> ('a exp -> 'b, bool , [`Bool ]) stage
  val reti : ('a exp -> 'b) -> ('a exp -> 'b, int , [`Int ]) stage
  val retf : ('a exp -> 'b) -> ('a exp -> 'b, float, [`Float]) stage

  val argb : (bool_e -> 'a, 'b, 'c) stage -> ('a, bool -> 'b, 'c) stage  
  val argi : (int_e -> 'a, 'b, 'c) stage -> ('a, int -> 'b, 'c) stage
  val argf : (float_e -> 'a, 'b, 'c) stage -> ('a, float -> 'b, 'c) stage

  val compile : ('a exp, 'b, 'a) stage -> 'b t
  val as_fun : 'a t -> 'a
  val source : 'a t -> string
end