On Mon, Jun 17, 2013 at 5:09 PM, Matthias Felleisen <matth...@ccs.neu.edu>wrote:
> > p.s. On second thought, for structs you want two constructors: > -- one that takes positional arguments > -- one that takes keyword arguments > My intent was that you could use both positional and keyword arguments at the same time, for each argument. This way, you may even avoid the new for `new', and use the procedure itself, i.e., with the same procedure or struct or class, you can simply write: (define (fish name weight) (list name weight)) and call it with: (fish #:name "Nemo" #:weight 700) or (fish "Nemo" 700) or (fish "Nemo" #:weight 700) and same for make-fish (for structs) and fish%. There would be no difference in the calling style between proc, struct and class. (Or maybe I misunderstood your point.) On Mon, Jun 17, 2013 at 5:28 PM, Neil Van Dyke <n...@neilvandyke.org>wrote: > I have used this in Python, and it is kinda neat and has its uses, but > overall, I prefer the current way in Racket. > > One reason I prefer the current way in Racket is that, if every argument > can be positional, then you have to keep this in mind when adding keyword > arguments to a procedure that is used by other code: new arguments can only > be added at the end of the list, even if that does not make the most sense > for documentation purposes. > Good point. Then one possibility is to allow to force an argument to be by-name only (I don't see a strong reason to allow to force an argument to be by-position only, except maybe to avoid bad proc-call habits, but not even sure). > Another reason is that the keyword arguments restrict the syntax somewhat, > so, when a mistaken extraneous sexp is where we'd expect a keyword, it is > flagged as an error, rather than be considered a positional argument. > > Related to the previous reason, if the programmer is *intentionally* > intermixing keyword arguments with positionals, such as "(foo 37 #:x 41 74 > #:a 34)", that seems error-like that I wish they would get an error and > change their ways. > I agree, although less strongly than for the above point. I wouldn't mind to force calls to take positional arguments first, and have no more positional arguments after the first keyword. (it actually seems to be easier to implement this way too.) Though note that currently Racket does allow things like that: (define (foo y #:x x ) (list x y)) (foo #:x 3 1) ; -> '(3 1) Laurent
_________________________ Racket Developers list: http://lists.racket-lang.org/dev
