(ignore-errors

            (parse-number string))))

         default)))

 (defparameter *csv-print-quote-p* t "print \" when the element is a string?")

 (defparameter *csv-default-external-format* :utf-8)

           (with-output-to-string (s)

             (let ((*standard-output* s)

                   (record-size (length record)))

               (loop for e across record

                     for i from 0

                     do (typecase e

                          (string (progn

                                    (if *csv-print-quote-p*

                                        (progn

                                          (write-char *csv-quote*)

                                          (write-string e)

                                          (write-char *csv-quote*))

                                        (write-string e))))

                          (t (princ e)))

                        (when (< i (1- record-size))

                          (write-char delimiter)))))))

                               :if-does-not-exist :create

                               :if-exists :supersede

                               :external-format external-format)

      (when (oddp q-count) (warn 'simple-warning :format-control "odd number of #\" in a line (~A)"

                                                 :format-arguments (list q-count)))

      (if (zerop q-count)

          (cl-ppcre:split delimiter str) ;(cl-ppcre:split *csv-separator* str)

          (macrolet ((push-f (fld flds) `(push (coerce (reverse ,fld) 'string) ,flds)))

            (loop with state = :at-first ;; :at-first | :data-nq | :data-q | :q-in-nq | q-in-q

                  with field with fields

                  for chr of-type character across str

                  do (cond ((eq state :at-first)

                            (setf field nil)

                            (cond ((char-equal chr *csv-quote*) (setf state :data-q))

                                  ((char-equal chr delimiter) (push "" fields))

                                  (t (setf state :data-nq) (push chr field))))

                           ((eq state :data-nq)

                            (cond ((char-equal chr *csv-quote*) (setf state :q-in-nq))

                                  ((char-equal chr delimiter)

                                   (push-f field fields)

                                   (setf state :at-first))

                                  (t (push chr field))))

                           ((eq state :q-in-nq)

                            (cond ((char-equal chr *csv-quote*) (setf state :q-in-q))

                                  ((char-equal chr delimiter)

                                   (push-f field fields)

                                   (setf state :at-first))

                                  (t (setf state :data-nq) (push chr field))))

                           ((eq state :data-q)

                            (cond ((char-equal chr *csv-quote*) (setf state :q-in-q))

                                  ((char-equal chr delimiter) (push-f field fields) (setf state :at-first))

                                  (t (push chr field))))

                           ((eq state :q-in-q)

                            (cond ((char-equal chr *csv-quote*) (setf state :data-q))

                                  ;; this should only be done conditionally - early escapes quotes

                                  ((char-equal chr delimiter)

                                   (push-f field fields)

                                   (setf state :at-first))

                                  (t

                                   ;; (error "illegal value ( ~A ) after quotation" chr)

                                   (push chr field)

                                   ))))

                  finally (return

                            (progn (push-f field fields) (reverse fields)))))))

       (let* ((line (string-trim '(#\Space #\Newline #\Return) rline))

                    (length type-conv-fns) (length strs))))

                    (length map-fns) (length strs))))

                   (map 'vector #'funcall type-conv-fns result)))

                   (map 'vector #'funcall map-fns result)))

           (when type-spec

             (macrolet ((make-num-specifier (specifier)

                          `(lambda (s) (let ((s (parse-number-no-error s s)))

                                         (if (numberp s) (funcall ,specifier s) s)))))

               (map 'vector

                    (lambda (type)

                      (ecase type

                        ((t nil string) #'identity)

                        (number #'(lambda (s) (parse-number-no-error s s)))

                        (float (make-num-specifier #'float))

                        (single-float (make-num-specifier #'(lambda (s) (coerce s 'single-float))))

                        (double-float (make-num-specifier #'(lambda (s) (coerce s 'double-float))))

                        (integer (make-num-specifier #'round))

                        (pathname #'pathname)

                        (symbol #'intern)

                        (keyword (lambda (s) (intern s :keyword)))))

                    type-spec))))

           (when map-fns

             (map 'vector

                  (lambda (fn)

                    (cond ((or (eq fn t)

                               (eq fn nil))

                           #'identity)

                          ((functionp fn)

                           fn)

                          ((and (symbolp fn)

                                (not (keywordp fn)))

                           (symbol-function fn))

                          (t (error "~a is not a valid function specifier." fn))))

                  map-fns)))

           (etypecase header

             (cons (coerce header 'vector))

             (boolean (when header

                        (read-csv-line stream :delimiter delimiter))))))

                                           :start start :end end)

           while rec

           collect rec into result

           finally (return

                     (values

                      (coerce result 'vector)

                      header)))))

                                  (start 0) end)

                        :delimiter delimiter

                        :start start :end end

                        :header header)))

           do (setf table

                    (stable-sort table (ecase order (:ascend #'string<=) (:descend #'string>=))

                                 :key (lambda (rec) (aref rec i))))

           finally (return table))))