The history of completions in the early 80s in #emacs got a significant and little-known community-decision anecdote from Kent last week see (listen) : https://gamerplus.org/@screwlisp/116524570149752933

When I mention the #CommonLisp #CLIM completions, I am talking about
https://www.lispworks.com/documentation/lw80/clim/clim-ch6-5.htm
i.e. the presentation-type of signature:
completion sequence &key test value-key
derived presentation-types. CLIM is descended from the #lispm #dynamicWindows .

@chiply
#mcclim

@sigue wrote:

«BTW, I don't want you to get the feeling that I'm making this a competition between CL and Dylan here. I actually really enjoy that you're making me think about how I might do some of this stuff in Dylan.»

Oh, I did not and do not view this as a competition, not at all.
And I am glad to learn a little bit about Dylan.

«This specific example is pretty straight-forward in Dylan:

let t = make(<table>);
t[#"foo"] := 1 + element(t, #"foo", default: 0);
// => 1»

Thank you.
Yes, that is how I do it in Python, too, when I need it (there are some minor syntactic differences, of course):
t['foo'] = 1 + t.get('foo', 0)

«In theory we could add `#key default` to the element-setter generic function and then this would work:

inc!(element(t, #"foo", default: 0));

One could also imagine syntax to supply a default value to t[k] such as t[k; d], and then this would work:

inc!(t[#"foo"; 0])»

Thank you; at the very least this is an interesting little exercise.

«A while ago I wrote up a proposal for an extension to Dylan that would provide similar functionality in https://opendylan.org/proposals/dep-0013-multi-assignment.html I think it needs work but it gets the idea across.»

I'm sure this is fun to work on.
Otherwise, I am just a side observer here, of course (regarding justification, acceptance, etc.).

«One might point out that the awesome thing about CL is that this can be done in-language instead of needing to modify the compiler. :)»

Oh, yes, oh, yes!

#CommonLisp
#Dylan

I was being facetious, but seriously, avoiding double evaluation is a lesser benefit of a modify macro.
A greater benefit is that it allows modification of a non-existent place, but one for which a default value can be supplied.
The usual example is with a hash table:

(let ((h (make-hash-table)))
(incf (gethash 'foo h 0))
(gethash 'foo h))
=> 1

I need this kind of thing every so often.

Otherwise, it is true that `define-modify-macro' itself is rarely needed, because the usual things are already provided.
I think I have used it once, maybe twice, perhaps to write `appendf' or something like that.

***

«The only thing Dylan provides that is similar to SETF is a simple rule:

f(...) := expression

is exactly equivalent to

f-setter(expression, ...)»

Thank you.

#CommonLisp
#Dylan

@sigue