Re: Initializing default arguments

From: Jacques Garrigue (garrigue@kurims.kyoto-u.ac.jp)
Date: Fri Jan 14 2000 - 04:00:12 MET

  • Next message: Jacques Garrigue: "Re: LablTk not in MS Windows O'Caml 2.99?"

    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>



    This archive was generated by hypermail 2b29 : Fri Jan 14 2000 - 08:57:23 MET