🚀 go-pugleaf

    I think it is intuitively obvious that for most such structures the
    application is in a far better position to know when the structure will
    be of no further use.

Whether obvious or not, I don't think this is true.  In complex
applications with shared data structures, the only way the application
can know when a structure will be of no further use is by maintaining
some kind of reference count, or by implementing a custom garbage
collector.  Automatic garbage collection is more reliable, and is
usually faster as well because more programming effort can be justified
for a general-purpose collector than for a single-purpose collector.

    ...A substantial portion of the time to GC isn't
    sticking cons cells back on the free list, but deciding which ones need
    to be so stuck. So I still claim having an explicit free (or at least
    some amount of low-level control on memory allocation, WHEN NEEDED AND
    APPROPRIATE) would be 'a good thing'.

At best, explicit deallocation takes time proportional to the number
of nodes being freed.  Modern garbage collectors can and often do
operate in less time than explicit deallocation, because they use
algorithms whose time is proportional to the number of nodes that
are live in heuristically chosen regions that have a low percentage
of live data.

Your argument is similar to the argument that explicit storage
overlays will always outperform automatic paging.  Garbage
collection has a theoretical advantage over explicit deallocation,
however, so the case for garbage collection is even stronger than
was the case for automatic paging.

William Clinger