anchor.diff:             :check-field
              :make-form
              :form-valid-p
  +           :form-errors
              :field-raw-value
              :field-value
  -           :field-error
  -           :field-error-format-string
  -           :form-errors))
  +           :field-error))
   
   (defvar *form-definitions* (make-hash-table :test #'eq))
   (defun ensure-form (name field-definitions)
  
positive.code:   (cadr (gethash field-name form)))
  (defun form-valid-p (form)
    (values (gethash *validp* form)))
  (defun field-error-format-string (form field-name)
    (caddr (gethash field-name form)))
  (defun field-error (form field-name)
    (format nil (field-error-format-string form field-name) (string-capitalize field-name)))
  (defun form-errors (form &aux errors)
    (maphash (lambda (field-name field-values)
               (unless (eq *validp* field-name)
                 (when-let (error-fmt (caddr field-values))
                   (push (cons field-name error-fmt) errors))))
             form)
    (nreverse errors))
  
  ;; (defun validate-email (email)
  ;;   (check-field email "Email is required."))
  ;; (defun validate-text-field (text &key max-length)
  ;;   (check-field text "Text is required.")
  ;;   (when max-length
  ;;     (check-field (>= max-length (length text)) "Field is too long.")))
  ;; (defun validate-password-field (&rest args)
  ;;   (apply #'validate-text-field args))
  ;; (defun validate-confirmation-field (&rest args)
  ;;   (apply #'validate-text-field args))
  ;; (defun validate-integer-field (maybe-int)
  ;;   (check-field maybe-int "Filed is required.")
  ;;   (check-field (ignore-errors (let (*read-eval*)
  ;;                                      (parse-integer maybe-int))) "Field must be an integer."))
  
  ;; (deform signup ()
  ;;   ((email 'validate-email)
  ;;    (display-name 'validate-text-field :max-length 30)
  ;;    (password 'validate-password-field)
  ;;    (confirmation 'validate-confirmation-field)
  ;;    (favorite-number 'validate-integer-field)))
  
negative.code: (defun make-form (form-class &optional binding-alist)
    (let ((def (find-form-def form-class))
          (form (make-hash-table :test #'eq)))
      (bind-form def form binding-alist)
      form))
  
  (defun field-raw-value (form field-name)
  