Seeing a discussion of copyright, I remembered that I am responsible for
SRFI 38, external representation for data with shared structure.

The code is in the SRFI document. SRFI 38 is in final status.  I went
and checked, and in the SRFI document, the heading over the example
implementation includes the line

 >>> Copyright (C) Ray Dillinger.  All Rights Reserved.

I'm sorry if that's ever been a problem. I don't actually remember
whether I put it there or not; it's been a long time and I don't use
LISP dialects much any more.  I haven't seen it in several years.

This email is to officially announce that I'm abandoning that copyright
claim (on both the code and the SRFI-38 document if needed) in favor of
whatever open source public licenses the SRFI editors want to license
them under.  If the MIT license is one that would cause no trouble in
your process, that's fine with me. I also give permission for the
aforementioned copyright or copyrights to be officially transferred from
my name to schemers.org.  Whoever maintains the website at schemers.org
may modify the copyright notice in the SRFI document accordingly.

That said, I don't think anyone really ought to use the code that's
under that copyright notice, so while this might be important to your
process and organization of SRFI's it definitely shouldn't be a
permission that actually matters to implementation authors.  Due to
limits on access to internals and the wish to be portable between
implementations, the code in the SRFI conforms to limitations in R5RS
expressibility.  It is therefore O(N^2), badly suboptimal compared to
the implementation that ought to appear in any high-quality scheme.

In particular implementation authors have the ability to compare
pointers, providing an easy way to make a total ordering of cons cells,
thereby an log-N search of cons cells, and thereby, finally, a superior
O(N-log-N) implementation of the SRFI.  A single-threaded scheme that
doesn't have immutable cells or make external calls sharing its data
structures can make an O(N) implementation (and fold it into a
simultaneous garbage collection, avoiding or delaying the need to do one
otherwise) by destructively modifying pointers as it works and then
patching them up before resuming the program.  So, apart from providing
a reference implementation to compare results with while debugging a
better version, I don't think the code in the SRFI, or the copyright on
it, has significant value to implementors.

Bear