anchor.diff:  
   
   ;; ## List Iteration
  -;; -----------------
  -
  -;; ### mapcar
  -;; (**mapcar** _fn_: [ll-functionp] _lst_: [listp] ...): [listp]
  -;;
  -;; TODO
  -;;
  -;; AutoLISP built-in.
  -
  -;; ### ll-maplist
  -;; (**ll-maplist** _fn_: [ll-functionp] _lst_: [listp]): [listp]
  +
  +;; ### (**mapcar** _fn_: [ll-functionp] _x_: [listp] ...): [listp]
  +;;
  +;; TODO
  +;;
  +;; AutoLISP built-in.
  +
  +;; ### (**ll-maplist** _fn_: [ll-functionp] _x_: [listp]): [listp]
   ;;
   ;; TODO
   (if *call:enable-preeval*
  -    (defun ll-maplist (fn lst / out) ; TODO: should it support improper lists?
  -      (car lst) ; raise error if not listp
  +    (defun ll-maplist (fn x / y) ; TODO: should it support improper lists?
  +      (car x) ; raise error if not listp
         (setq fn (eval fn))
  -      (while lst
  -        (setq out (cons (fn lst) out)
  -              lst (cdr lst)))
  -      (reverse out))
  -    (defun ll-maplist (fn lst / out) ; TODO: should it support improper lists?
  -      (car lst) ; raise error if not listp
  -      (while lst
  -        (setq out (cons (apply fn (list lst)) out)
  -              lst (cdr lst)))
  -      (reverse out)))
  -
  -;; ### ll-maptree
  -;; (**ll-maptree** _fn_: [ll-functionp] _tree_: [listp]): [listp]
  +      (while x
  +        (setq y (cons (fn x) y)
  +              x (cdr x)))
  +      (reverse y))
  +    (defun ll-maplist (fn x / y) ; TODO: should it support improper lists?
  +      (car x) ; raise error if not listp
  +      (while x
  +        (setq y (cons (apply fn (list x)) y)
  +              x (cdr x)))
  +      (reverse y)))
  +
  +;; ### (**ll-maptree** _fn_: [ll-functionp] _x_: [listp]): [listp]
   ;;
   ;; TODO
   ; FIXME: !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   ; FIXME: (if *call:enable-preeval*
  -(defun ll-maptree (fn tree / out pend cur pendlst newlst)
  +(defun ll-maptree (fn x / y pend cur pendlst newlst)
     ;; based on STDLIB std-mapatom
     ;; see ll-flatten
     (cond
  -    ((atom tree) (apply fn (list tree)))
  +    ((atom x) (apply fn (list x)))
       (t
        ;; loop until last element, for '(1 2 . 3) too
  -     (while (not (atom tree)) ; (consp tree)
  -       (setq pend (cons (car tree) pend)
  -             tree (cdr tree)))
  -     (setq out (if tree (apply fn (list tree)))
  +     (while (not (atom x)) ; (consp x)
  +       (setq pend (cons (car x) pend)
  +             x (cdr x)))
  +     (setq y (if x (apply fn (list x)))
              pendlst nil
              newlst nil)
        (while pend
          (while pend
            (setq cur (car pend) pend (cdr pend))
            (if (atom cur)
  -             (setq out (cons (apply fn (list cur)) out))
  +             (setq y (cons (apply fn (list cur)) y))
                (progn
                  (setq pendlst (cons pend pendlst)
  -                     newlst (cons out newlst) pend nil)
  +                     newlst (cons y newlst) pend nil)
                  (while (not (atom cur)) ; (consp cur)
                    (setq pend (cons (car cur) pend) cur (cdr cur)))
  -               (setq out (if cur (apply fn (list cur)))))))
  +               (setq y (if cur (apply fn (list cur)))))))
          (while (and pendlst (null pend))
  -         (setq out (cons out (car newlst)) newlst (cdr newlst)
  +         (setq y (cons y (car newlst)) newlst (cdr newlst)
                  pend (car pendlst) pendlst (cdr pendlst))))
  -     out)))
  -
  -;; ### ll-some
  -;; (**ll-some** _pred_: [ll-functionp] _lst_: [listp]): [ll-booleanp]
  +     y)))
  +
  +;; ### (**ll-some** _pred_: [ll-functionp] _x_: [listp]): [ll-booleanp]
   ;;
   ;; TODO
   ;;
   ;; Similar to VisualLISP `vl-some`, but may accept only one list.
   (if (and (not *call:ignore-vlisp*)
            vl-some)
  -    ;; NOTE: LispEx allows improper list, VisualLISP not.
  -    (defun ll-some (pred lst)
  -      (vl-some pred lst))
  -    (defun ll-some (pred lst)
  -      (and (ll-member-if pred lst))))
  -
  -;; ### ll-every
  -;; (**ll-every** _pred_: [ll-functionp] _lst_: [listp]): [ll-booleanp]
  +    ;; NOTE: BricsCAD LISP allows improper list, VisualLISP not.
  +    (defun ll-some (pred x)
  +      (vl-some pred x))
  +    (defun ll-some (pred x)
  +      (and (ll-member-if pred x))))
  +
  +;; ### (**ll-every** _pred_: [ll-functionp] _x_: [listp]): [ll-booleanp]
   ;;
   ;; TODO
   ;;
   ;; Similar to VisualLISP `vl-every`, but may accept only one list.
   (if (and (not *call:ignore-vlisp*)
            vl-every)
  -    ;; NOTE: LispEx allows improper list, VisualLISP not.
  -    (defun ll-every (pred lst)
  -      (vl-every pred lst))
  -    (defun ll-every (pred lst)
  -      (not (ll-member-if-not pred lst))))
  -
  -;; ### ll-foldl
  -;; (**ll-foldl** _fn_: [ll-functionp] _init_: [ll-anyp] _lst_: [listp]): [listp]
  +    ;; NOTE: BricsCAD LISP allows improper list, VisualLISP not.
  +    (defun ll-every (pred x)
  +      (vl-every pred x))
  +    (defun ll-every (pred x)
  +      (not (ll-member-if-not pred x))))
  +
  +;; ### (**ll-foldl** _fn_: [ll-functionp] _init_: [ll-anyp] _x_: [listp]): [listp]
   ;;
   ;; The fundamental list iterator.
  +;;
   ;; TODO
   ;; `ll-foldl` passes parameters to _fn_ in the same order as Scheme does,
   ;; i.e. `(fn current-item accumulator)`.
  
positive.code: ;;
  ;; The equivalent to missing `ll-reduce-from-end-with-init` is `ll-foldr`.
  ;;
  ;; For performance reasons, you should use `(apply fn lst)` instead of
  ;; `(ll-reduce fn lst)` when possible.
  ;;
  ;;     (ll-reduce '* '(1 2 3 4 5)) => 120
  ;;     (ll-reduce '- '(1 2 3 4))
  
negative.code:     (defun ll-consp (v)
        (not (atom v)))) ; (eq 'LIST (type v))
  
  ;; ### (**listp** _v_: [ll-anyp]): [ll-booleanp]
  ;;
  ;; Returns `t` if _v_ is a *cons* cell or `nil`, `nil` otherwise.
  ;;
  