[racket-dev] Keywords

Here's a simple demo for procedures if you want to try it out:
https://gist.github.com/Metaxal/5851215

Laurent


On Mon, Jun 24, 2013 at 4:54 PM, Laurent <laurent.orseau at gmail.com> wrote:

>
>
>
> On Mon, Jun 17, 2013 at 5:09 PM, Matthias Felleisen <matthias at 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 <neil at 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
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/dev/archive/attachments/20130624/3d207686/attachment.html>