On 2021-07-22 19:14 -0400, John Cowan wrote:
> >  I'd like to read more before
> > developing this point, but I believe it's crucial that dictionaries
> > either support both approaches or be divided into two classes.
> >
>
> "Facts are stubborn things."  Some dictionaries (that already exist)
> support mutation only, some (again, that already exist) don't support
> mutation but do support functional update, some in the future may be
> completely immutable (perfect hash tables, anyone?).  So as I mentioned in
> an earlier post, ! here means "may mutate": you get back the possibly-new,
> possibly-old object and have to use it henceforth, which is the definition
> of linear-update.

A related question: How much inference of generic procedures can we
expect a SRFI 225 implementation to do?  The spec for
register-dictionary-type! mentions "the versions automatically
provided by the implementation"; does this mean that we can expect
any dict- procedure to work on arbitrary dictionaries?  If so, we
must be able to define all of the procedures of this SRFI in terms of
the argumnets to register-dictionary-type!; this is not currently
possible.  If not, what happens when you call an unimplemented
procedure?  (The sample implementation simply calls 'error'.)

I believe that we should be able to expect any dict- procedure to
work on any dictionary.  To do this, a minimal set of procedures
will have to be selected which can be used to implement the rest.
There is simply no way around providing primitive non-mutative
forms; there's no way to implement dict-map, e.g., in terms of
dict-map!.  The alternative is a library which is not truly generic;
any procedure can blow up if you call it on the wrong object, so
you'll have to know about the internals of the dictionaries you're
operating on.  That's an obvious abstraction leak.

Side note: The name of register-dictionary! should be updated to
register-dictionary-type! in the sample implementation.

Further to the side note: The examples for dict-map->list, etc.
look alright to me, now; I suppose I was not at my sharpest when I
first read them.  I might suggest the additional example

    (dict-map->list (lambda (k v) v) dict) => (2 4 6),

which is pretty direct, I think.

--
Wolfgang Corcoran-Mathe  <xxxxxx@sigwinch.xyz>

"Never do programs contain so few bugs as when no debugging tools
are available." --Niklaus Wirth