anchor.diff:  (defmethod to-lisp ((field select-field))
     (unless (emptyp (field-str field)) (field-str field)))
   
  +(defmethod validate-field ((field select-field) val)
  +  (when val
  +    (if (assoc val (select-choices field) :test #'equal)
  +        val
  +        (error 'field-error :message "Invalid choice"))))
   
   (defun make-choices (list val-maker txt-maker &key (optional t))
     (let ((choices (loop for el in list
  -                      collect (list (funcall val-maker el)
  -                                    (funcall txt-maker el)))))
  +                      collect (list (princ-to-string (funcall val-maker el))
  +                                    (princ-to-string (funcall txt-maker el))))))
       (if optional
           (cons (list "" "--") choices)
           choices)))
  
positive.code:         (prototype (spawn-form formset)))
      (multiple-value-bind (form-params n-forms)
          (loop for (kw field) on (form-fields prototype) by #'cddr
             for name = (field-name field)
             for param = (and name (assoc name params :test #'equalp))
             when param
             collect (cons kw (cdr param)) into pparams
             and maximize (length (cdr param)) into mlen
             finally (return (values pparams mlen)))
        (loop with forms = (loop repeat n-forms collect (spawn-form formset))
             for (kw param) in form-params
             when param
             do (loop for form in forms
                   for par in param
  
negative.code: 
  (defmethod full-validate ((formset formset))
    (loop for form in (formset-forms formset)
         for errors = (and (form-boundp form) (full-validate form))
         when errors
         collect errors into form-errors
         finally (when form-errors
  