anchor.diff:  ;;                      (1+ (/ len step)))
   ;;         end (+ start (* step len)))
   ;;   (repeat
  -;;     (setq lst (cons (setq end (- end step)) lst))))
  +;;     (setq x (cons (setq end (- end step)) x))))
   
   
   ;; ## List Selectors
  -;; -----------------
  -
  -;; ### car
  -;; (**car** _p_: [ll-consp]): [ll-anyp]
  +
  +;; ### (**car** _p_: [ll-consp]): [ll-anyp]
   ;;
   ;; Returns the value referred to by the first slot of the cons cell _p_.
   ;; In other words, it returns the car of _p_.
  
positive.code: 
  
  ;; ## List Iteration
  ;; -----------------
  
  ;; ### mapcar
  ;; (**mapcar** _fn_: [ll-functionp] _lst_: [listp] ...): [listp]
  ;;
  ;; TODO
  ;;
  ;; AutoLISP built-in.
  
  ;; ### ll-maplist
  ;; (**ll-maplist** _fn_: [ll-functionp] _lst_: [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
        (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]
  ;;
  ;; TODO
  ; FIXME: !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  ; FIXME: (if *call:enable-preeval*
  (defun ll-maptree (fn tree / out pend cur pendlst newlst)
    ;; based on STDLIB std-mapatom
    ;; see ll-flatten
    (cond
      ((atom tree) (apply fn (list tree)))
      (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)))
             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))
               (progn
                 (setq pendlst (cons pend pendlst)
                       newlst (cons out 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)))))))
         (while (and pendlst (null pend))
           (setq out (cons out (car newlst)) newlst (cdr newlst)
                 pend (car pendlst) pendlst (cdr pendlst))))
       out)))
  
  ;; ### ll-some
  ;; (**ll-some** _pred_: [ll-functionp] _lst_: [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]
  ;;
  ;; 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]
  ;;
  ;; The fundamental list iterator.
  ;; TODO
  ;; `ll-foldl` passes parameters to _fn_ in the same order as Scheme does,
  ;; i.e. `(fn current-item accumulator)`.
  
negative.code: ;;
  ;; AutoLISP built-in.
  
  ;; ### (**ll-revappend** _x_: [listp] _v_: [ll-anyp]): [listp]
  ;;
  ;; TODO
  ;; If v is a list then (ll-revappend x v) == (append (reverse x) v)
  ;;
  ;;     (ll-revappend '(1 2 3) '()) => (3 2 1)
  ;;     (ll-revappend '(1 2 3) '(a . b)) => (3 2 1 A . B)
  