LetRec the way you want it IS in Common-lisp

[Jim McDonald <edsel!jlm@labrea.Stanford.EDU>]

>   In common-lisp you can get the reader to do this for you:
>   
>   ==> (prog1 nil (setf foo '#1=(a . #1#)))
>   nil
>   ==> (first foo)
>   a
>   ==> (second foo)
>   a
>   ==> (third foo)
>   a

That was my first reaction, but this creates a global structure.
I think the goal is to get a dynamically generated recursive
structure.  You could do something awful like 

  (let ((foo (eval (read-from-string "'#1=(a . #1#)"))))
    ...)

but this seems too bletcherous to suggest as a canonical solution.

Perhaps one could extend backquote to include something like the #n=
feature of the reader.  (Perhaps this feature is already in backquote
and I don't know about it?)  The following unhappy syntax should not
be that hard to implement:

  (let ((foo `,=1=(a ,.=1=)))
    ...)

Someone who cares could improve on it.

To return to the original question:
Assuming that backquote (or whatever) could give you dynamically
created recursive data structures, and that recursive forms in general
are impossible to handle, is there something in-between that you want?

  jlm