Re: Writing a function/macro in Elisp that generates a function at runtime

[Toby Cubitt <tsc25@cantab.net>]

Toby Cubitt wrote:
> Barry Margolin wrote:
>> You don't need to generate a function on the fly for this.  Do something 
>> like this:
>>
>> (defun insert-with-function (insfun new-data old-cell)
>>   (setf (cell-data old-cell)
>>         (funcall insfun new-data (cell-data old-cell)))
>>   old-cell)
> 
> Hmmmm...the simplest ideas are always best. This does sound like a
> better approach. Thanks!

I've now remembered why this won't work, at least not straightforwardly.

I have a higher-level data structure built on top of a lower-level one.
Internally, the higher-level structure stores data "cells" in the
lower-level structure. The lower-level structure of course knows nothing
about this. It just stores any kind of data, without knowing anything
about its structure. And users of the higher-level structure also know
nothing about the data cells, which are part of the internal
implementation. As far as users are concerned, they can just store data
of whatever kind they like in the higher-level structure.

For the lower-level structure, I have defined exactly this kind of
insert-with-function, called say `low-level-insert-with-function'. What
I'm trying to do is to define a `high-level-insert-with-function' for
the higher-level data structure. Clearly, it has to call
`low-level-insert-with-function' to insert the data into the lower-level
structure on which it is build, something like:

(defun high-level-insert-with-function (higher-structure data insfun)
  (low-level-insert-with-function
   (higher-structure--get-lower-structure higher-structure)
   data ??insfun??))

Now insfun knows nothing about the data cells, since it was passed in by
the user. And `low-level-insert-with-function' knows nothing about data
cells, since it acts on the lower-level data structure.

So it would seem I need to wrap insfun on the fly in the above function,
to make it aware that the data is actually stored within "cells". And
we're back to the problem from my previous mail: how to generate a
wrapped insfun on the fly, in such a way that the setf macro required to
enter data into a "cell" is expanded into the cell-data accessor
function at compile-time.

I still don't see why this should be fundamentally impossible. The
function can easily be generated on the fly by a backquote construct (as
in my first attempt), and all the necessary information for
macro-expanding setf is there at compile-time. It's 'just' a question of
getting macro-expansion to be carried out within the backquote construct
(which is what I was trying in my second attempt).

Probably there's a different way of approaching the problem that I'm not
seeing.

Thanks for your help (and sorry for the lengthy explanation),

Toby