How to correctly pass arguments on Common Lisp? - lisp

Question

I'm currently reading Practical Common Lisp, and I decided to try and improve its first example (simple database), just to practice.
I'm trying to make the update function more generic, like the select function.
Here's my code, it runs but doesn't actually update anything like it should.
(defun make-if-expr (field value)
`(if ,value (setf (getf row ,field) ,value)))
(defun make-if-list (fields)
(loop while fields
collecting (make-if-expr (pop fields) (pop fields))))
(defun update (selector-fn &rest clauses)
(setf *db*
(mapcar
#'(lambda (row)
(when (funcall selector-fn row)
(apply #'make-if-list clauses))
row)
*db*)))
This is modified from the original source code, available in the link.
As an example, using ((:TITLE "Title" :ARTIST "Artist" :RATING 7 :RIPPED T)) as a database, typing in (update (where :title "Title") (list :title "New Title")) in the REPL should change the title to "New Title". It doesn't, though.
There is no error, no nothing. It just doesn't work.
Since I'm a complete beginner at Common Lisp, can anyone tell me what am I doing wrong? I'm pretty sure I'm not passing arguments to functions correctly.

Answer 1

MAKE-IF-LIST creates a list of lists and returns it. You are not doing anything with them and thus nothing happens.
It's also not clear why you are creating the lists, since you could just write a function which does the update.

Answer 2

This is not directly related to your problem, but:
(defun make-if-expr (field value)
`(if ,value (setf (getf row ,field) ,value)))
... injects value at two different places, which means it is going to be evaluated twice when non-nil. This is problematic if computing the value takes time or if it performes side-effects. You should probably introduce a variable to hold that value:
(defun make-if-expr (field value)
(let ((symbol (gensym)))
`(let ((,symbol ,value))
(if ,symbol (setf (getf row ,field) ,symbol)))))

Answer 3

I suppose you are trying to make update work similiarly to how where was implemented with a macro at the end of the chapter. In that case, what you're doing wrong is simply that your update is not a macro. You need to change it into one, and use the backtick syntax to evaluate the necessary parts (selector-fn and (make-if-list ...)):
(defmacro update (selector-fn &rest clauses)
`(setf *db*
(mapcar
#'(lambda (row)
(when (funcall ,selector-fn row)
,#(make-if-list clauses))
row)
*db*)))
(setf *db* (list (list :TITLE "Title" :ARTIST "Artist" :RATING 7 :RIPPED T)))
(update (where :title "Title") :title "New Title")
*db*
; => ((:TITLE "New Title" :ARTIST "Artist" :RATING 7 :RIPPED T))
Edit: As Rainer Joswig said in the comments, the code above does have some problems. In reality you would have to make sure you don't evaluate variables multiple times, and you shouldn't use symbols that may be used by the surrounding code. The book should cover that in later chapters, but a better, although a bit more complicated, version of the code would look like this (Also see coredumps answer, since I didn't want to steal that into this):
;; You need to pass the `row-sym` here, because this can't
;; rely on the row being called `row` (which it isn't).
;; You'll also want to see the answer by coredump regarding this.
(defun make-if-expr (field value row-sym)
`(if ,value (setf (getf ,row-sym ,field) ,value)))
(defun make-if-list (fields row-sym)
(loop while fields
collecting (make-if-expr (pop fields) (pop fields) row-sym)))
(defmacro update (selector-fn &rest clauses)
;; You need to use `gensym` to generate unique names
;; for all symbols you use in the expanded code.
(let ((selector-sym (gensym "selector-fn"))
(row-sym (gensym "row")))
;; Assign `selector-fn` into a variable. This avoids the
;; function being built by the `where` macro multiple times.
`(let ((,selector-sym ,selector-fn))
(setf *db*
(mapcar
;; You have to use the unique symbols generated above,
;; so the `*-sym` variables are evaluated with a comma.
#'(lambda (,row-sym)
(when (funcall ,selector-sym ,row-sym)
,#(make-if-list clauses row-sym))
,row-sym)
*db*)))))

Answer 4

Thanks to the wonderful tips everyone gave me, I was able to solve my problem.
I was trying to generate the ifs inside the update function, which only makes sense using macros. Instead, I used a single function now.
This is my new code, hopefully it will be useful for people having similar problems:
(defun update-if (field value row)
(setf (getf row field) value))
(defun update-if-list (fields row)
(loop while fields
do (update-if (pop fields) (pop fields) row)))
(defun update (selector-fn &rest clauses)
(setf *db*
(mapcar
#'(lambda (row)
(when (funcall selector-fn row)
(update-if-list clauses row))
row)
*db*)))