On 30 Jul 2021, at 23:32, John Cowan <xxxxxx@ccil.org> wrote:

> On Fri, Jul 30, 2021 at 3:03 AM Daphne Preston-Kendal <xxxxxx@nonceword.org> wrote:
>
>>> > In R7RS, :|123| is always going to be indistinguishable from |:123|; this has nothing to do with keywords being disjoint or not.
>>
>> *In*distinguishable? At present, the former in Chibi gives me a symbol which the writer gives back out as |:\|123\||; |:123| is a symbol :123.
>
> Actually it seems that :|123| is indeterminate in the R7RS formal syntax, which only allows tokens without |s or with one at each end.

Then we can safely define either

keyword → ⟨identifier⟩ :
(DSSSL style)
*or*
keyword → : ⟨identifier⟩
(Common Lisp style)

in Large, no? Assuming we choose to have some kind of lexical keyword type (which I think would be a good idea, notwithstanding programs that use them probably automatically lose small portability).

>> > Default vs. no-default keywords:  the signature of CL's `make-array` is (make-array dimensions &key adjustable fill-pointer displaced-to displaced-index-offset element-type initial-element initial-contents).  Of these, all have defaults except the last two, or perhaps it is more accurate to say the default is implementation-specified.  But it is definitely not nil, because filling the array with nils is not the same as not filling the array.
>>
>> Are you saying that in CL, if I pass nil explicitly to all those keyword arguments of make-array, it has a different effect to if I’d omitted them?
>
> Yes. Specifically:
> <snipped for brevity>

Okay, so there’s some internal magic going on here to detect which keywords were actually passed and supply the defaults, despite there being no defaults in the method signature? Or does CL have another way to do that detection?

>> I will mention it, but I don’t think even Guile supports this in Scheme. What’s the intended use?
>
> To wrap a keyword function in another keyword function, thus (from CLHS):
>
>  (defun array-of-strings (str dims &rest named-pairs
>                           &key (start 0) end &allow-other-keys)
>    (apply #'make-array dims
>           :initial-element (subseq str start end)
>           :allow-other-keys t
>           named-pairs))
>
> The &allow-other-keys allows make-array arguments to be accepted by array-of-strings without having to enumerate them in the lambda-list, which allows implementation-specific keywords to be passed (for example, a keyword that causes the array to be stored in unmanaged memory).  However, make-array does not make use of keywords :start and :end, but by specifying :allow-other-keys, the call to apply will not reject them.  (Note that `apply` itself has no keywords, so all the key-value pairs passed to it are simply prepended to named-pairs.)

Ahhh. Okay. Hmm. Thank you for the explanation.

Daphne