Correct! The problem is in the line right after that, where it says ((cons nil lst) (append lst nil) (insertat nil lst 3) … The issue is the two opening parentheses. Parentheses can change meaning in special contexts (like the cond form you’re using), but in this context, the parentheses signify regular function application, just … Read more
General principle Suppose you have the following range function: (defun range (start end &optional (step 1)) (loop for x from start below end by step collect x)) You can accept another parameter, a function, and call it for each element: (defun range-generator (callback start end &optional (step 1)) (loop for x from start below end … Read more
What you are missing is that in Lisp parentheses are meaningful. In C/Java/Python &c, the following expressions are the same: a+b (a+b) (a)+(b) (((a)+(b))) (((((a)+(b))))) In Lisp, the following expressions are very different: a — a symbol (a) — a list with a single element, which is the symbol a (1 (2)) — a list … Read more
The Bad test-a is self-modifying code. This is extremely dangerous. While the variable x disappears at the end of the let form, its initial value persists in the function object, and that is the value you are modifying. Remember that in Lisp a function is a first class object, which can be passed around (just … Read more
‘(0 0 0) is a literal object, which is assumed to be a constant (albeit not protected from modification). So you’re effectively modifying the same object every time. To create different objects at each function call use (list 0 0 0). So unless you know, what you’re doing, you should always use literal lists (like … Read more
Are you doing something like this: CL-USER> (defun foo () (let ((value ‘(1))) ; ‘(1) is literal data (incf (car value)))) FOO CL-USER> (foo) 2 CL-USER> (foo) 3 CL-USER> (foo) 4 CL-USER> (foo) 5 Quoted data is literal data; there’s only one copy of it, and the consequences of modifying it are undefined. The behavior … Read more
You might like to read this paper by Richard Gabriel. It is a summary of the issues that the Lisp community were discussing in Lisp1 vs Lisp2. It’s a bit dense and slow moving in the first few sections, but is much easier to read by the time you get past section 5. Basically, Lisp1 … Read more
Short answer Bypass the default evaluation rules and do not evaluate the expression (symbol or s-exp), passing it along to the function exactly as typed. Long Answer: The Default Evaluation Rule When a regular (I’ll come to that later) function is invoked, all arguments passed to it are evaluated. This means you can write this: … Read more
There are several reasons why one should not use EVAL. The main reason for beginners is: you don’t need it. Example (assuming Common Lisp): EVALuate an expression with different operators: (let ((ops ‘(+ *))) (dolist (op ops) (print (eval (list op 1 2 3))))) That’s better written as: (let ((ops ‘(+ *))) (dolist (op ops) … Read more
(symbol-function ‘foo) is a Generalized Variable in elisp, so you can use: (setf (symbol-function ‘forward-word) #’backward-word) as an alternative to: (fset ‘forward-word #’backward-word) (As a side-note, you can do the same thing with cl-letf as a replacement for the deprecated flet when you want to override a function using dynamic scope.)