anchor.diff:       (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)))))
  +                   (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))
  +                       :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))))))
  +                       :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))
  
positive.code: 
  (defun create-table (name size db)
    (with-lock
        (if (symbolp name)
            (if (and (> size 0)
                     (integerp size))
                (unless (getf (db-tables db) name)
                  (setf (getf (db-tables db) name)
                        (make-array size :initial-element nil)))
                (warn "Invalid size of table: ~A, must be a positive integer" size))
            (warn "Invalid name of type: ~A, must be a symbol" (type-of name)))))
  
  (defun create-col (name table &optional &key pred)
    (with-lock
        (if (symbolp name)
            (unless (< (first-nil table) 0)
              (setf (aref table (first-nil table)) (list :name name :data (list) :pred (if pred
                                                                                           pred
                                                                                           #'(lambda (x)
                                                                                               (declare (ignore x))
                                                                                               t)))))
            (warn "Invalid name of type: ~A, must be a symbol" (type-of name)))))
  
  (defun insert (values table)
    (cond
  
negative.code:   (:use :cl)
    (:export
     ;;DB-OPs:
     #:set-db-path
     #:create-db
     #:create-table
     #:create-col
  