At 1:39 AM -0800 6/3/01, Chris Hecker wrote:
>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.
>
>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...
>
>It doesn't seem to partially evaluate the function or anything 
>insane like that.

Let me have an attempt at this, even though I'm a beginner too :-)


In OCaml, *all* functions actually take *one* argument.  When you write...

    let f x y = Printf.printf "%d %d" x y;Printf.printf "%d"

... it is actually just shorthand for a function that takes *one* 
argument (x) and returns as it's result a function that takes *one* 
argument (y) and prints x and y and then returns a function that 
takes one argument and prints it.

val f: int -> int -> int -> unit

.. actually means...

val f: int -> (int -> (int -> unit)))

.. it's just that since -> is right-associative you don't need the brackets.

Your first function would be perhaps better written as:

val f: int -> int -> (int -> unit)

But you don't need the parens :-)


In Scheme your first function would be like this:

(define f
   (lambda (x)
     (lambda (y)
       (display x)
       (display " ")
       (display y)
       (lambda (a)
         (display a)))))

(((f 1) 2) 3)


How does an OCaml function know how many arguments to take?  It's 
*always* one.  So you don't need the parens that you do in scheme. 
And if a function returns another function then applying it to the 
next argument in line is automatic.

This would of course be very inefficient if the compiler didn't do 
clever things...

-- Bruce
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr