lisp

I'm learning Lisp from the book 'Practical Common Lisp'. At one point, I'm supposed to enter the following bit of code: [1] (remove-if-not #'evenp '(1 2 3 4 5 6 7 8 9 10)) (2 4 6 8 10) I suppose the idea here is of course that remove-if-not wants a function that can return either T or NIL when an argument is provided to it, and this function is then applied to all symbols in the list, returning a list containing only those symbols where it returned NIL. However, if I now write the following code in CLISP: [2] (remove-if-not 'evenp '(1 2 3 4 5 6 7 8 9 10) (2 4 6 8 10) It still works! So my

I am reading the SICP book Here about the imperative programming model. I could not understand the illustration in two points: W.r.t. the arrow from square to the "pair" (the two circles): What does this arrow mean? Though throughout this section, an arrow means "enclosing environment", this specific arrow seems not pointing to an environment.( square 's environment is the global env , not the "pair") Is below a correct understanding: in the value of a procedure definition, its "code text" part (the left circle) has no interpretation of the symbols within. They are just "text". Only at

I do not see why we need nil [1] when to cons a sequence (so-called proper list) of items. It seems to me we can achieve the same goal by using the so-called improper list ( cons -ed pairs without an ending nil ) alone. Since Lisps [2] have already provided a primitive procedure to distinguish between a pair? and an atom (some implementations even provide atom? ), when defining a procedure on a list, e.g., length , I can do the same with just dotted-pairs, as shown below: (define len (lambda (l) (cond ((pair? l) (+ 1 (len (cdr l)))) (else 1) ) ) ) It is obvious that we can apply this procedure

I have a Lisp program that's going through nested list and deleting elements that match the element passed through to the function. My issue is, if everything in one of the nested list is deleted, I need to print out () instead of NIL. (defun del (x l &optional l0) (cond ((null l) (reverse l0)) ((if (atom x) (eq x (car l)) (remove (car l) x)) (del x (cdr l) l0)) (T (del x (cdr l) (cons (if (not (atom (car l))) (del x (car l)) (car l)) l0))))) (defun _delete(a l) (format t "~a~%" (del a l))) (_delete 'nest '(nest (second nest level) (third (nest) level))) This returns ((SECOND LEVEL (THIRD NIL