Initializing default arguments

Initializing default arguments

[Markus Mottl]

Hello,

I just wondered about ways to get rid of definitions like

  let rec foo_aux init = ...
  let foo = foo_aux []

using labels and default arguments. There I found a problem with functions
like:

  let rec tautology ?(:vs = variables t) t = ...

It is not possible to reference arguments (here: 't') from default
arguments if they appear later in the function definition.  It is clear
that this would be problematic if the other argument also had a default
value and if it referenced the first value again (recursion).

However, I believe it should be always ok to use non-default arguments
regardless of order, because they are always already initialized.

The following does not work as intended

  let rec tautology t ?(:vs = variables t) = ...

because I would have to place further arguments after it so that the
default argument can be erased (e.g. by adding '()'). Although the latter
requirement is not really painful it is at least not as convenient as it
could be.

Is it possible to remove this restriction or are there further problems I
did not foresee?

Best regards,
Markus Mottl

-- 
Markus Mottl, mottl@miss.wu-wien.ac.at, http://miss.wu-wien.ac.at/~mottl

Re: Initializing default arguments

[Jacques Garrigue]

From: Markus Mottl <mottl@miss.wu-wien.ac.at>

> using labels and default arguments. There I found a problem with functions
> like:
> 
>   let rec tautology ?(:vs = variables t) t = ...
> 
> It is not possible to reference arguments (here: 't') from default
> arguments if they appear later in the function definition.  It is clear
> that this would be problematic if the other argument also had a default
> value and if it referenced the first value again (recursion).
> 
> However, I believe it should be always ok to use non-default arguments
> regardless of order, because they are always already initialized.

We indeed thought about it. It is technically possible, since the
compiler automatically moves the computation of [variables t] inside
the body of the function. The only difficulty is that it changes the
definition of scopes. Currently you can use several times the same
variable in a function definition:

        # let ck x x = x;;
        val ck : 'a -> 'b -> 'b = <fun>

With the new semantics you suggest, this would be ambiguous.
On the other hand, prohibiting the above function definition might
seem reasonable.

Another problem is cascading definitions:

  let sub ?(:pos = 0) ?(:len = String.length s - pos) s =
    String.sub s pos len

Here we want to access the value of pos inside the default definition
of len. Again we can consider all these definitions as working in the
same scope, and do a topological sort to get the right order.

Last, what to do with definitions like:

  let f ?(:x = y) = fun y -> ...
  let f ?(:x = y) : int -> int = fun y -> ..

Should we refuse both, accept both, accept only the first one ?
Currently the parser does not distinguish between the first one and
let f  ?(:x = y) y = ...

Conclusion: this is possible, and if nobody opposes I think it should
be in a future release. Since it's a bit tricky to implement I do not
say 3.00.

By the way, there is a workaround. Write by hand what the compiler
generates:

  let rec tautology ?:vs t =
    let vs = match vs with None -> variables t | Some x -> x in
    ...

A bit heavier, but works ok in 2.99.

Regards,

        Jacques
---------------------------------------------------------------------------
Jacques Garrigue      Kyoto University     garrigue at kurims.kyoto-u.ac.jp
		<A HREF=http://wwwfun.kurims.kyoto-u.ac.jp/~garrigue/>JG</A>