Defining macro to convert "address" into nested caar's and cddrs - macros

Question

I am just now learning about macros. I find them really cool as a concept, but I still have a really hard time programming them, as this post will amply demonstrate.
I'm posting this question because I could not solve an exercise I set up for myself.
Basically, I want to define the "macro-equivalent" of the following function:
(defun fn-get-at (deeply-nested-thing address)
(if address
(if (eql (car address) 'l)
(fn-get-at (caar deeply-nested-thing) (cdr address))
(fn-get-at (cddr deeply-nested-thing) (cdr address)))
deeply-nested-thing))
As an example of how one would use this function, if I first set
(setf deeply-nested-thing
'((((((((NIL) N)) O (NIL) P)) Q (((NIL) S)) R))
T (((NIL) U (NIL) V)) W (((NIL) X)) Y (NIL) Z))
...then I could evaluate (fn-get-at deeply-nested-thing '(l l r)) to get ((NIL) P). In this example, the address parameter is the list '(l l r), where the 'l and 'r stand for "go left" and "go right", respectively. One can think of this list as a set of directions, starting from the root node of some binary tree1.
So far, so good. Now I would like to define macro-get-at, a macro version of fn-get-at. With this macro, the expression (macro-get-at deeply-nested-thing '(l l r)) should expand to2
(cddr (caar (caar deeply-nested-thing)))
My first attempt was this:
(defmacro macro-get-at (deeply-nested-thing address)
(if address
(if (eql (car address) 'l)
`(macro-get-at (caar ,deeply-nested-thing) ,(cdr address))
`(macro-get-at (cddr ,deeply-nested-thing) ,(cdr address)))
deeply-nested-thing))
This did not meet my already extremely low expectations. I had expected that
(pprint (macroexpand-1 '(macro-get-at deeply-nested-thing '(l l r))))
...would, at worst, output something like
(MACRO-GET-AT (CAAR DEEPLY-NESTED-THING) '(L R))
Instead, I got this:
(MACRO-GET-AT (CDDR DEEPLY-NESTED-THING) ((L L R)))
To me, baffling. First, since the output has CDDR rather than CAAR, I must conclude that the (eql (car address) 'l) test in macro-get-at evaluated to nil; I don't get it: the same test behaves correctly in fn-get-at. Second, I just can't make any sense of that ((L L R)) in the output.
My second (and final) attempt was this:
(defmacro macro-get-at (deeply-nested-thing address)
(if address
(if (eql (car address) 'l)
`(macro-get-at (caar ,deeply-nested-thing) (cdr ,address))
`(macro-get-at (cddr ,deeply-nested-thing) (cdr ,address)))
deeply-nested-thing))
The results of this are marginally better, but still completely wrong. The macroexpand-1 output this time is:
(MACRO-GET-AT (CDDR DEEPLY-NESTED-THING) (CDR '(L L R)))
Again, the CDDR is wrong (though that's to be expected, since my new version does not address this problem at all). The second argument in the expansion is at least nominally correct, but if one simulates recursively expanding the resulting macro expression, one can see that the process will be an infinite loop (since the second argument of every expansion will always be non-null):
* (pprint (macroexpand-1 (macroexpand-1 (macroexpand-1 (macroexpand-1 '(macro-get-at deeply-nested-thing '(l l r)))))))
(MACRO-GET-AT (CDDR (CDDR (CDDR (CDDR DEEPLY-NESTED-THING))))
(CDR (CDR (CDR (CDR '(L L R))))))
I hope that by now I have given enough evidence of my cluelessness to elicit the flinging of a few merciful cluebricks my way.
1 Granted, in this example, it is not at all easy, at least for me, to see that the sequence "turn left, turn left, turn right" corresponds to ((NIL) P).
2 Note that the order of caar's and cddr's corresponds to the order of the reverse of the "address" '(l l r).

Answer 1

Your first attempt works.
(defparameter *deeply-nested-thing*
'((((((((NIL) N)) O (NIL) P)) Q (((NIL) S)) R))
T (((NIL) U (NIL) V)) W (((NIL) X)) Y (NIL) Z))
(defmacro macro-get-at (deeply-nested-thing address)
(if address
(if (eql (car address) 'l)
`(macro-get-at (caar ,deeply-nested-thing) ,(cdr address))
`(macro-get-at (cddr ,deeply-nested-thing) ,(cdr address)))
deeply-nested-thing))
CL-USER 14 > (macroexpand '(macro-get-at *deeply-nested-thing* (l l r)))
(CDDR (CAAR (CAAR *DEEPLY-NESTED-THING*)))
T
CL-USER 12 > (macro-get-at *deeply-nested-thing* (l l r))
((NIL) P)
Macros don't evaluate their arguments, so list of directions has to be written as (l l r). In each step of recursion, car is removed:
(cdr (l l r)) => (L R)
(cdr (L R)) => (R)
(cdr (R)) => NIL
You used '(l l r)- and this happened inside macro:
(cdr (quote (l l r)) => ((L L R))
(cdr ((L L R))) => NIL

Answer 2

Replacing functions by macros is never a good idea in a modern Lisp (there were some uses for it in very antique Lisps). Macros transform source code to other source code: a macro compiles a language into a simpler language, it does not operate on run-time data.
So what you need to be thinking about is what language this macro will understand and what it needs to emit. Well, the language it consumes is something like:
a name for some kind of expression;
a list of the names of zero or more single-argument operations to perform on that expression, in the order given, with the value of each operation being the argument to the next.
And the language it will produce is going to be a bit of CL source which does this.
So, well, lets first write a slightly simpler thing than yours. Lets write a macro which lets you, for instance say:
(-> thing car cdr cdr)
and will turn this into (cdr (cdr (car thing)))
Note this takes any number of arguments, not an argument and an argument which must be a list of operations, because why have extra useless parens?
Note also that this is kind of like a Unix pipeline: it pipes its first argument through a number of operations
Here's a macro which does that: as with many cases where you have something with an &rest argument it's usually convenient to do most of the work with an auxiliary function:
(defmacro -> (e &body opnames)
(labels ((expand-> (otail)
(if (null otail)
e
`(,(first otail) ,(expand-> (rest otail))))))
(expand-> (reverse opnames))))
Another way to implement this which in some ways is nicer (well, I think so) is:
(defmacro -> (e &body opnames)
(do* ((otail opnames (rest otail))
(expression (if (not (null otail))
`(,(first otail) ,e)
e)
(if (not (null otail))
`(,(first otail) ,expression)
expression)))
((null otail) expression)))
So now we've got this thing, but we're stuck with operation names being function names. But that's fine, we can now turn this into something very close to your get-at macro:
(defmacro get-at (thing &body lrs)
`(-> ,thing ,#(mapcar (lambda (op)
(ecase op
(l 'caar)
(r 'cddr))) lrs)))
And now you have both get-at and a much more general tool.

Answer 3

Solution by a function
Though the question is about a macro, this can be solved entirely by a function:
(defun get-at (nested-thing commands)
(let ((result nested-thing)
(lookup (list (cons 'l #'caar) (cons 'r #'cddr))))
(loop for c in commands
do (setf result (funcall (cdr (assoc c lookup)) result))
finally (return result))))
This function is like an interpreter for the mini l-r-language.
Let's test:
(setf deeply-nested-thing
'((((((((NIL) N)) O (NIL) P)) Q (((NIL) S)) R))
T (((NIL) U (NIL) V)) W (((NIL) X)) Y (NIL) Z))
(get-at deeply-nested-thing '(l l r))
;; => ((NIL) P)
Solution by a macro
As a macro, you could construct the code using cons into code:
(defmacro get-at (nested-thing commands)
(let ((atable '((l . caar) (r . cddr)))
(code (list nested-thing)))
(loop for c in commands
do (setf code (list (cons (cdr (assoc c atable)) code)))
finally (return (car code)))))
Test it:
(macroexpand-1 '(get-at deeply-nested-thing (l l r)))
;; (CDDR (CAAR (CAAR DEEPLY-NESTED-THING))) ;
;; T
(get-at deeply-nested-thing (l l r))
;; => ((NIL) P)