anchor.diff:  
   
   ;; # Lists
  -;; =======
   
   
   ;; ## List Predictates
  -;; -------------------
  -
  -;; ### atom
  -;; (**atom** _v_: [ll-anyp]): [ll-booleanp]
  +
  +;; ### (**atom** _v_: [ll-anyp]): [ll-booleanp]
   ;;
   ;; Returns `t` if _v_ is an *atom*, `nil` otherwise.
   ;;
  
positive.code: ;;     tail
  ;;       => (4 5)
  ;;
  ;; Equivalent to `(list (ll-firstn list n) (ll-nthcdr n list))`, except that it
  ;; can be faster.
  (if (and (not *call:ignore-lispex*)
           vle-sublist)
      (defun ll-split-at (n lst)
        (if (< 0 n)
            (list (vle-sublist lst 0 n) (vle-sublist lst n 0))
            (list nil lst)))
      (defun ll-split-at (n lst / out)
        (nth n (list nil)) ; raise error if not natnump
        (while (and lst (< 0 n))
          (setq n (1- n)
                out (cons (car lst) out)
                lst (cdr lst)))
        (list (reverse out) lst)))
  
  ;; ### ll-split-at-first
  ;; (**ll-split-at-first** _v_: [ll-anyp] _lst_: [listp]): [listp]
  ;;
  ;; TODO
  ;;
  ;; Identical to LispEx `vle-list-split`.
  ;; Similar to Express Tools `acet-list-split`, but with reverse argument
  ;; order.
  (if (and (not *call:ignore-lispex*)
           vle-list-split)
      (setq ll-split-at-first vle-list-split)
      (defun ll-split-at-first (v lst / out)
        (while (and lst
                    (not (equal v (car lst))))
          (setq out (cons (car lst) out)
                lst (cdr lst)))
        (list (reverse out) lst)))
  
  ;; ### ll-split-at-last
  ;; (**ll-split-at-last** _v_: [ll-anyp] _lst_: [listp]): [listp]
  ;;
  ;; TODO
  (defun ll-split-at-last (v lst / in out)
    ;; TODO: OPTIMIZE: search & save pointer, then search more
    (setq in (reverse lst))
    (while (and in
                (not (equal v (car in))))
      (setq out (cons (car in) out)
            in (cdr in)))
    (if in
        (cons (reverse (cdr in)) (cons (car in) out)) ;---!!! FIXME
        (list lst)))
  
  ;; ### ll-partition
  ;; (**ll-partition** _n_: [ll-natnump] _lst_: [listp]): [listp]
  ;;
  ;; TODO
  ;;
  ;;     (ll-partition 2 '(a b c d e)) => ((a b)(c d))
  ;;
  (defun ll-partition (n lst) ; split-every, chunk
    (*error* "ll-partition: Function not implemented")) ;--- TODO
  
  ;; ### ll-partition-all
  ;; (**ll-partition-all** _n_: [ll-natnump] _lst_: [listp]): [listp]
  ;;
  ;; TODO
  ;;
  ;;     (ll-partition-all 2 '(a b c d e)) => ((a b)(c d)(e))
  ;;
  (defun ll-partition-all (n lst)
    (*error* "ll-partition-all: Function not implemented")) ;--- TODO
  
  ;; ### ll-separate
  ;; (**ll-separate** _pred_: [ll-functionp] _lst_: [listp]): [listp]
  ;;
  ;; TODO
  ;;
  ;;     (ll-separate 'numberp '(a b 1 c 2)) => ((1 2) (a b c))
  ;;
  (if *call:enable-preeval*
      (defun ll-separate (pred lst / in out)
        (setq pred (eval pred))
        (foreach x lst
          (if (pred x)
              (setq in (cons x in))
              (setq out (cons x out))))
        (list (reverse in) (reverse out)))
      (defun ll-separate (pred lst / in out)
        (foreach x lst
          (if (apply pred (list x))
              (setq in (cons x in))
              (setq out (cons x out))))
        (list (reverse in) (reverse out))))
  
  
  ;; ## List Operations
  ;; ------------------
  
  ;; ### length
  ;; (**length** _lst_: [listp]): [natump]
  ;;
  ;; Returns the number of elements in _lst_.
  ;;
  ;; It is an error if _lst_ is an improper list.
  ;;
  ;;     (length '(1 2 3)) => 3
  ;;     (length '()) => 0
  
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)
  