Можно ли считать список integer без парсинга?

(defun split-by-one-space (string)
    (loop for i = 0 then (1+ j)
          as j = (position #\Space string :start i)
          collect (subseq string i j)
          while j))
          
;;(defun arr-sum () ())
 
(setf parameters (split-by-one-space(read-line)))        
(setf arr (split-by-one-space(read-line)))

(defconstant +buffer-size+ 1024)
 
(defclass buffered-input (sb-gray:fundamental-character-input-stream)
  ((buffer :initform (make-array +buffer-size+ :element-type 'base-char))
   (start :initform 0)
   (end :initform 0)
   (stream :reader buffered-input-stream :initarg :stream))) 
 
(defun fill-buffer (bi)
  (with-slots (buffer start end stream) bi
    (setf end (read-sequence buffer stream)
          start 0))
  bi)
 
(defun make-buffered-input (stream)
  (fill-buffer (make-instance 'buffered-input :stream stream)))
 
(defmethod sb-gray:stream-read-char ((bi buffered-input))
  (with-slots (buffer start end stream) bi
    (cond ((< start end)
           (prog1
             (aref buffer start)
             (incf start)))
          ((= end +buffer-size+)
           (sb-gray:stream-read-char (fill-buffer bi)))
          (t :eof))))
 
(defun get-integer (&optional (stream *standard-input*))
  (declare (optimize (speed 3) (safety 0) (space 0) (debug 0)))
    (let ((digit (read-char stream nil))
          (number 0))
      (declare (type fixnum number))
      (if digit
          (loop
            (setf number (the fixnum (+ (the fixnum (* 10 number))
                                        (the fixnum (- (char-code digit) (char-code #\0)))))
                  digit (read-char stream nil))
            (unless (and digit (digit-char-p digit))
              (return (values number digit))))
          (values nil nil))))
 
(defvar *elem* nil)       
 
(let ((in (make-buffered-input *standard-input*)))
  (loop
    (multiple-value-bind (n c) (get-integer in)
      (cond ((null n) (return))
            ((or (null c) (eql c #\Newline)) (push n *elem*) (return))
            (t (push n *elem*))))))
    
(princ *elem*)