Who are you running from?

run-length-encoding.lisp

(defun make-stack ()
  (make-array 0 :fill-pointer 0 :initial-element nil))

(defun stack-push! (stack item)
  (vector-push-extend item stack))

(defun run-length-encode (string)
  (declare (type string string))
  (let ((octets (string-to-octets string))
        (stack (make-stack))
        (state (list :length 0 :octet nil)))
    (labels ((set-state! (&key length octet)
               (setf state (list :length length :octet octet)))
             (write-record! ()
               (stack-push! stack (getf state :length))
               (stack-push! stack (getf state :octet)))
             (has-dangling-record? ()
               (not (eq (getf state :octet) nil)))
             (add-octet! (octet)
               (when (eq (getf state :octet) nil)
                 (setf (getf state :octet) octet))
               (when (/= octet (getf state :octet))
                 (write-record!)
                 (set-state! :length 0 :octet octet))
               (incf (getf state :length))))
      (map nil #'add-octet! octets)
      (when (has-dangling-record?)
        (write-record!))
      stack)))


(mapcar (lambda (x)
          (cons x (run-length-encode x)))
        '("a" "ab" "abc" "aabbcc"))

(run-length-encode "AABBCCDDDDDDDDDDDDDDDDDD")