[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Alternative formulations of keywords



On 11-Apr-06, at 10:54 PM, John Cowan wrote:

Marc Feeley scripsit:

But doesn't this require that all named parameters be supplied?  So
it does not help with named optional parameters.

No, it merely requires the existence of a run-time object that
uniquely represents "unsupplied value".

The error checking is also very poor.

I don't understand this point.

Then I clearly misunderstand your proposals. Can you explain your proposals in more detail? What I think you are saying in your first proposal is that keywords are entirely handled at compile time. The compiler sorts the keywords and transforms the call into one with required parameters and positional optional parameters. So

   (foo 'bar foo: 32 bar: 54)   becomes   (foo 'bar 54 32)
(foo 'bar xyz: 32 abc: 54) becomes (foo 'bar 54 32) no error detected?
   (foo 'bar bar: 54)           becomes   (foo 'bar 54)
   (foo 'bar foo: 32)           becomes   (foo 'bar 32)
   (foo 'bar)                   becomes   (foo 'bar)

How is foo going to determine which parameters were supplied? Are you assuming that the compiler has some knowledge about foo so that it knows the complete set of named optional parameters and can pass the "unsupplied value" for the parameters that are not supplied? In general this is impossible because the function to call may be computed, as in:

   ((f x) 'bar foo: 32 bar: 54)

(f x) might return foo sometimes and at other times a function that accepts additional named optional parameters.

For the second proposal you have to assume the general case where you are passing computed expressions, such as:

   (foo 'bar foo: (f x) bar: (g x))

which would have to be transformed into

   (foo 'bar (list (cons 'foo: (f x)) (cons 'bar: (g x))))

Is this correct?

Marc