Home     About     Download     Resources     Contact us

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

Browse thread
[Caml-list] currying...
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: 2001-03-07 (16:00) From: Remi VANICAT Subject: Re: [Caml-list] currying...
```Chris Hecker <checker@d6.com> writes:

> How does caml know when to call a function?  For example, say I have:
>
> val f: int -> int -> int -> unit
>
> and the definition of f is
>
> let f x y = Printf.printf "%d %d" x y;Printf.printf "%d"
>
> so f actually takes two ints, prints them, and then returns a
> function that takes an int and returns unit.  From the val
> declaration above in a .cmi file, how can caml tell the difference
> between that f and this one:
>
> let f x y z = Printf.printf "%d %d %d" x y z
>
> How does it know "when" to call f, since you need a different number
> of parameters for the different definitions?  The top f prints x y
> when it's called with two parms, so it doesn't wait until all three
> parms have been passed.

there is a problem here : Printf.printf is a strange function, it
process argument one by one. A better vision of the problem can be see by
using print_int :

# let f x y = print_int x; print_char ' '; print_int y; print_int;;
val f : int -> int -> int -> unit = <fun>
# f 1;;
- : int -> int -> unit = <fun>
# f 1 2;;
1 2- : int -> unit = <fun>
# f 1 2 3;;
1 23- : unit = ()
# let f x y z = print_int x; print_char ' '; print_int y; print_int z;;
val f : int -> int -> int -> unit = <fun>
# f 1;;
- : int -> int -> unit = <fun>
# f 1 2;;
- : int -> unit = <fun>
# f 1 2 3;;
1 23- : unit = ()

in fact, when caml create a function, it build a closure, and the
closure contain the information of how many argument it need to be
evaluate.

>
> I have a feeling I'm missing something fundamental here, or else the
> definition of a function internally has a field for its arity and it
> just partially applies until it reaches the total arity.  I thought
> I remembered seeing some documentation on this months ago, but I
> can't find it now...

yes, there is such a field. I've never seen a documentation about it,
but it is clear when you read the output of
ocaml -dinstr
and the byterun/interp.c file of the source code

>
> It doesn't seem to partially evaluate the function or anything
> insane like that.

it mostly true, with the remarkable exception of printf

--
Rémi Vanicat
vanicat@labri.u-bordeaux.fr
http://dept-info.labri.u-bordeaux.fr/~vanicat
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

```