(in-package :uiop/common-lisp)

#| FAIL:
(defun frob-substrings (string substrings &optional frob)
  (declare (optimize (speed 0) (safety #-gcl 3 #+gcl 0) (debug 3)))
  (let ((length (length string)) (stream nil))
    (labels ((emit-string (x &optional (start 0) (end (length x)))
               (when (< start end)
                 (unless stream (setf stream (make-string-output-stream)))
                 (write-string x stream :start start :end end)
                 (describe stream)))
             (emit-substring (start end)
               (when (and (zerop start) (= end length))
                 (return-from frob-substrings string))
               (emit-string string start end))
             (recurse (substrings start end)
               (cond
                 ((>= start end))
                 ((null substrings) (emit-substring start end))
                 (t (let* ((sub-spec (first substrings))
                           (sub (if (consp sub-spec) (car sub-spec) sub-spec))
                           (fun (if (consp sub-spec) (cdr sub-spec) frob))
                           (found (search sub string :start2 start :end2 end))
                           (more (rest substrings)))
                      (cond
                        (found
                         (recurse more start found)
                         (etypecase fun
                           (null)
                           (string (emit-string fun))
                           (function (funcall fun sub #'emit-string)))
                         (recurse substrings (+ found (length sub)) end))
                        (t
                         (recurse more start end))))))))
      (recurse substrings 0 length))
    (if stream (get-output-stream-string stream) "")))

(defun frob (string substrings &optional frob)
  (declare (optimize (speed 0) (safety #-gcl 3 #+gcl 0) (debug 3)))
  (block nil
    (let ((length (length string)) (stream nil))
      (labels ((emit-string (x &optional (start 0) (end (length x)))
                 (when (< start end)
                   (unless stream (setf stream (make-string-output-stream)))
                   (write-string x stream :start start :end end)
                   (describe stream)))
               (emit-substring (start end)
                 (when (and (zerop start) (= end length))
                   (return string))
                 (emit-string string start end))
               (recurse (substrings start end)
                 (cond
                   ((>= start end))
                   ((null substrings) (emit-substring start end))
                   (t (let* ((sub-spec (first substrings))
                             (sub (if (consp sub-spec) (car sub-spec) sub-spec))
                             (fun (if (consp sub-spec) (cdr sub-spec) frob))
                             (found (search sub string :start2 start :end2 end))
                             (more (rest substrings)))
                        (cond
                          (found
                           (recurse more start found)
                           (etypecase fun
                             (null)
                             (string (emit-string fun))
                             (function (funcall fun sub #'emit-string)))
                           (recurse substrings (+ found (length sub)) end))
                        (t
                         (recurse more start end))))))))
        (recurse substrings 0 length))
      (if stream (get-output-stream-string stream) ""))))

(defun frob (string substrings &optional frob)
  (declare (optimize (speed 0) (safety #-gcl 3 #+gcl 0) (debug 3)))
  (block nil
    (let ((length (length string)) (stream nil))
      (labels ((emit-string (x &optional (start 0) (end (length x)))
                 (when (< start end)
                   (unless stream (setf stream (make-string-output-stream)))
                   (write-string x stream :start start :end end)
                   (describe stream)))
               (emit-substring (start end)
                 (when (and (zerop start) (= end length))
                   (return string))
                 (emit-string string start end))
               (recurse (substrings start end)
                 (cond
                   ((>= start end))
                   ((null substrings) (emit-substring start end))
                   (t (let* ((sub-spec (first substrings))
                             (sub (if (consp sub-spec) (car sub-spec) sub-spec))
                             (fun (if (consp sub-spec) (cdr sub-spec) frob))
                             (found (search sub string :start2 start :end2 end))
                             (more (rest substrings)))
                        (cond
                          (found
                           (recurse more start found)
                           (etypecase fun
                             (null)
                             (string (emit-string fun))
                             (function (funcall fun sub #'emit-string)))
                           (recurse substrings (+ found (length sub)) end))
                        (t
                         (recurse more start end))))))))
        (recurse substrings 0 length))
      (if stream (get-output-stream-string stream) ""))))

(defun frob (string substrings &optional frob)
  (block nil
    (let ((length (length string)) (stream nil))
      (labels ((emit-string (x &optional (start 0) (end (length x)))
                 (when (< start end)
                   (unless stream (setf stream (make-string-output-stream)))
                   (write-string x stream :start start :end end)
                   (describe stream)))
               (emit-substring (start end)
                 (when (and (zerop start) (= end length))
                   (return string))
                 (emit-string string start end))
               (recurse (substrings start end)
                 (cond
                   ((>= start end))
                   ((null substrings) (emit-substring start end))
                   (t (let* ((sub-spec (first substrings))
                             (sub (if (consp sub-spec) (car sub-spec) sub-spec))
                             (fun (if (consp sub-spec) (cdr sub-spec) frob))
                             (found (search sub string :start2 start :end2 end))
                             (more (rest substrings)))
                        (cond
                          (found
                           (recurse more start found)
                           (etypecase fun
                             (null)
                             (string (emit-string fun))
                             (function (funcall fun sub #'emit-string)))
                           (recurse substrings (+ found (length sub)) end))
                          (t
                           (recurse more start end))))))))
        (recurse substrings 0 length))
      (if stream (get-output-stream-string stream) ""))))

(defun frob (string substrings &optional frob)
  (let ((length (length string)) (stream nil))
    (labels ((emit-string (x &optional (start 0) (end (length x)))
               (when (< start end)
                 (unless stream (setf stream (make-string-output-stream)))
                 (write-string x stream :start start :end end)
                 (describe stream)))
             (emit-substring (start end)
               (when (and (zerop start) (= end length))
                 (return string))
               (emit-string string start end))
             (recurse (substrings start end)
               (cond
                 ((null substrings) (emit-substring start end))
                 (t (let* ((sub (first substrings))
                           (found (search sub string :start2 start :end2 end))
                           (more (rest substrings)))
                      (cond
                        (found
                         (recurse more start found)
                         (recurse substrings (+ found (length sub)) end))
                        (t
                         (recurse more start end))))))))
      (recurse substrings 0 length))
    (if stream (get-output-stream-string stream) "")))

(defun frob (string substrings &optional frob)
  (block nil
    (let ((length (length string)) (stream nil))
      (labels ((emit-string (x &optional (start 0) (end (length x)))
                 (when (< start end)
                   (unless stream (setf stream (make-string-output-stream)))
                   (write-string x stream :start start :end end)))
               (emit-substring (start end)
                 (emit-string string start end))
               (recurse (substrings start end)
                 (cond
                   ((null substrings) (emit-substring start end))
                   (t (let* ((sub (first substrings))
                             (found (search sub string :start2 start :end2 end))
                             (more (rest substrings)))
                        (cond
                          (found
                           (recurse more start found)
                           (recurse substrings (+ found (length sub)) end))
                          (t
                           (recurse more start end))))))))
        (recurse substrings 0 length))
      (if stream (get-output-stream-string stream) ""))))

(defun frob (string substrings &optional frob &aux stream)
  (labels ((emit-string (x &optional (start 0) (end (length x)))
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string x stream :start start :end end)))
           (emit-substring (start end)
             (emit-string string start end))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-substring start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (recurse more start found)
                       (recurse substrings (+ found (length sub)) end))
                      (t
                       (recurse more start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))

(defun frob (string substrings &optional frob &aux stream)
  (labels ((emit-string (start end)
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string string stream :start start :end end)))
           (emit-substring (start end)
             (emit-string start end))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-substring start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (recurse more start found)
                       (recurse substrings (+ found (length sub)) end))
                      (t
                       (recurse more start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))

(defun frob (string substrings &optional frob &aux stream)
  (labels ((emit-string (start end)
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string string stream :start start :end end)))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-string start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (recurse more start found)
                       (recurse substrings (+ found (length sub)) end))
                      (t
                       (recurse more start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))


(defun frob (string substrings &optional frob &aux stream)
  (labels ((emit-string (start end)
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string string stream :start start :end end)))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-string start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (recurse more start found)
                       (recurse substrings (+ found (length sub)) end))
                      (t
                       (emit-string start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))
|#

(defun frob (string substrings &optional frob &aux stream)
  (labels ((emit-string (start end)
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string string stream :start start :end end)))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-string start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (recurse more start found)
                       (recurse substrings (+ found (length sub)) end))
                      (t
                       (emit-string start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))

(defun tst ()
  (trace write-string get-output-stream-string)
  (prog1
      (frob "~@<Error blah: ~3i~_~A~@:>" '("~3i~_"))
    (untrace write-string get-output-stream-string)))

#| WORK
(defun frob (string substrings &optional frob &aux stream)
  (labels ((emit-string (start end)
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string string stream :start start :end end)))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-string start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (emit-string start found)
                       (recurse substrings (+ found (length sub)) end))
                      (t
                       (emit-string more start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))

(defun frob (string substrings &optional frob &aux stream)
  (labels ((emit-string (x &optional (start 0) (end (length x)))
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string x stream :start start :end end)))
           (emit-substring (start end)
             (emit-string string start end))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-substring start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (emit-substring start found)
                       (emit-substring (+ found (length sub)) end))
                      (t
                       (emit-substring start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))

(defun frob (string substrings &optional frob &aux (stream (make-string-output-stream)))
  (labels ((emit-string (x &optional (start 0) (end (length x)))
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string x stream :start start :end end)))
           (emit-substring (start end)
             (emit-string string start end))
           (recurse (substrings start end)
             (cond
               ((null substrings) (emit-substring start end))
               (t (let* ((sub (first substrings))
                         (found (search sub string :start2 start :end2 end))
                         (more (rest substrings)))
                    (cond
                      (found
                       (recurse more start found)
                       (recurse substrings (+ found (length sub)) end))
                      (t
                       (recurse more start end))))))))
    (recurse substrings 0 (length string)))
  (if stream (get-output-stream-string stream) ""))

(defun borf (fun a b c d)
  (funcall fun a b)
  (funcall fun c d))

(defun frob (string substrings &optional frob &aux (stream (make-string-output-stream)))
  (labels ((emit-string (x &optional (start 0) (end (length x)))
             (when (< start end)
               (unless stream (setf stream (make-string-output-stream)))
               (write-string x stream :start start :end end)))
           (emit-substring (start end)
             (emit-string string start end)))
    (let* ((sub (first substrings))
           (found (search sub string))
           (more (rest substrings)))
      (when found (borf #'emit-substring 0 found (+ found (length sub)) (length string)))))
  (if stream (get-output-stream-string stream) ""))

(defun frob1 ()
  (let ((s (make-string-output-stream)))
    (write-string "abcdefghijklmnopqrstuvwxyz" s :start 0 :end 5)
    (write-string "abcdefghijklmnopqrstuvwxyz" s :start 20 :end 25)
    (get-output-stream-string s)))

(defun frob2 ()
  (let ((s (make-string-output-stream)))
    (labels ((f (x y)
               (write-string "abcdefghijklmnopqrstuvwxyz" s :start x :end y)))
      (f 0 5)
      (f 20 25))
    (get-output-stream-string s)))
|#

