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

Re: Alternative formulations of keywords

This page is part of the web mail archives of SRFI 89 from before July 7th, 2015. The new archives for SRFI 89 contain all messages, not just those from before July 7th, 2015.

On Apr 12, Marc Feeley wrote:
> Most Scheme systems allow separate compilation (think of "load").
> If one file contains:
> (define (f #!key (x 11) (y 22)) (+ x y))
> (define (g z) (f y: z))
> and the other contains:
> (set! f (lambda (#!key (y 33) (z 44)) (* y z)))
> You have the same problem.  So it doesn't suffice for the function
> definition to be global.

IIUC, John's proposal can be implemented using modules in PLT as

  (define (foo x #!key y z)

is translated to

  (define (hidden-foo x y z)
  (define-syntax (foo stx)
    ... analyze stx for keyword syntaxes, and construct a call for
    ... hidden-foo with plain arguments)

where hidden-foo is an identifier that is not accessible outside the
macro.  When I wrote our library, I considered this approach, but it
seems like it's much less useful, basically a completely different
mechanism for only named arguments.  It didn't take us long to reach
exactly this conclusion:

> The way I see it you are forbidding the use of higher-order functions  
> in combination with named optional parameters.  That would be a  
> serious limitation for a functional language like Scheme.

          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
                  http://www.barzilay.org/                 Maze is Life!