anchor.diff:           (error "Invalid argument, [integer] or selector only")
            (with-lock
              (loop :for i :in p
  -              :collect (loop :for j :from 0 :to (1- (length table))
  -                          :collect (nth i
  -                                        (getf (aref table j) :data)))))))
  +                 :collect (loop :for j :from 0 :to (1- (length table))
  +                                :collect (nth i
  +                                              (getf (aref table j) :data)))))))
       (selector
        (let ((pivot (lookup-table (selector-col p) table)))
          (if (equal pivot 'DNE)
              (error "Invalid selector with pivot column: ~A" (selector-col p))
              (with-lock
                (loop :for i :from 0 :to (1- (length pivot))
  -                :when (funcall (selector-pred p) (nth i pivot))
  -                :collect (loop :for j :from 0 :to (1- (length table))
  -                            :collect (nth i (getf (aref table j) :data))))))))))
  +                   :when (funcall (selector-pred p) (nth i pivot))
  +                     :collect (loop :for j :from 0 :to (1- (length table))
  +                                    :collect (nth i (getf (aref table j) :data))))))))))
   
   ;;N could be a function that takes the index and the current value
   (defun update (p n table)
  
positive.code:      (with-lock
         (if (= (length values) (length table))
             (let ((types
                    (loop :for i :from 0 :to (1- (length table))
                       :collect (funcall (getf (aref table i) :pred) (nth i values)))))
               (if (loop :for i :from 0 :to (1- (length types))
                      :when (not (nth i types))
                      :do (warn "Type: ~A of values at: ~A doesn't match the predicate of column" (type-of (nth i values)) i)
                      :always (nth i types))
                   (loop :for i :from 0 :to (1- (length table))
                      :do (setf (getf (aref table i) :data) (cons (nth i values)
                                                                  (getf (aref table i) :data))))))
             (warn "Values doesn't match table size: ~A" (length table)))))))
  
  (defun get-pos (&key db (table nil) (col nil) (pos nil))
  
negative.code:                                  (if (consp c)
                                       (create-col (car c)
                                                   (get-pos :db ',db :table tbl)
                                                   :pred (eval (cadr c)))
                                       (create-col c
                                                   (get-pos :db ',db :table tbl))))
                               cols))
  