While Loop

(while condition 
  sequence of expressions)

• Execute the sequence of expressions while the condition is true.
• Specific to elisp.

Examples

(defun count_div (x)
  (let ((count 0) (i 1))
    (while (<= i x)
       (if (eq (% x i) 0)
          (setq count (1+ count)))
       (setq i (+ 1 i)))
    count))
 (count_div 12)  ; => 6

(defun last (L)
  (let ((M L))
    (while (and M (cdr M))
      (setq M (cdr M)))
    (print L)
    (if M (car M) nil)))
(last '(1 2 3 4)) ;-> 4
(last ())         ;-> nil
(last '(1))       ;-> (1)

Simplified version of last considering that both car and cdr return nil when the list is empty:

(defun last (L)
  (let ((M L))
    (while (cdr M)
      (setq M (cdr M)))
    (car M)))
(last '(1 2 3 4)) ;-> 4
(last ())         ;-> nil
(last '(1))       ;-> 1

Function Parameters
All function parameters are value parameters in Lisp:

(defvar LL '(1 2 3 4))

(defun last (L)
  (while (and L (cdr L))
    (setq L (cdr L)))
  (car L))

(last LL)  ;=> 4
LL         ;=> (1 2 3 4)

(defun plus (x)
  (setq x (+ 1 x)))

(setq n 3) ;=> 3
(plus n)   ;=> 4
n          ;=> 3

Associative Lists

• A list where the elements are pairs of keys associated with values.
• (setq flowers '((rose . red) (lily . white) (iris . purple)))
• It makes it easy to find values associated with the keys:
• (assoc 'lily flowers ) ; (lily . white)
• (rassoc 'purple flowers ) ; (iris . purple)
• assq, rassq - same as assoc and rassoc but use eq instead of equal.
• copy-alist - a 2-level deep copy of the list.

Mutators

• Mutators are functions that modify their parameters. The others are called accessors.
• Some built-in Lisp-elisp functions are mutators. Examples: setq, push, pop.
• By default user-defined functions are accessors. If your function calls a mutator, then it becomes a mutator.

List Mutators

• Functions that modify the content of a list (like push).
• setcar, setcdr. Replace the car or cdr of a list with the value of the second argument.

  (setq L '(1 2 3))
  (setcar (cdr L) 4) ;=> 4
  L ;=> (1 4 3)
  (setcdr (cdr L) 5) ;=> L - (1 4 . 5)
  

• Modifying an element of an associated list:

  (setcdr (assq 'rose flowers) 'pink)
  => flowers - ((rose . pink) (lily . white) ...)
  

Mutator Function

(defun set3rd (L val)
  (let ((M L))
    (setq M (cdr M))
    (setq M (cdr M))
    (setcar M val)
    L))
(setq L '(3 5 9 1 2))  ;=>  (3 5 9 1 2)
(set3rd L 10)          ;=>  (3 5 10 1 2)
L                      ;=>  (3 5 10 1 2)

Complex Conditional

(cond (c1 exp1) (c2 exp2)... )

• Evaluates each condition until one of them is true.
• When that happens, it evaluates the expression(s) associated with it.
• If none of them is true, it returns nil.
• Each of the cases can contain a sequence of expressions (not just one).
• Equivalent to a sequence of nested simple conditionals or a sequence of if - elif - else.

Examples

(defun last (L)
  (cond ((not L) nil)
        ((not (cdr L)) (car L))
        (t (last (cdr L)))))
(defun max3 (n1 n2 n3)
  (cond
   ((and (>= n1 n2) (>= n1 n3)) n1)
   ((and (>= n2 n1) (>= n2 n3)) n2)
   ((and (>= n3 n1) (>= n3 n2)) n3)))