(define-library (csc strings)
  (export
    contains
    find
    join
    not-found-error?
    prefix?
    split
    str-quote)
  (import (scheme base)
          (only (scheme case-lambda) case-lambda)
          (only (scheme write) write)
          (only (csc list) intercalate)
          (only (csc loop) loop))
  (begin


    (define prefix?
      (case-lambda
        ((prefix str) (prefix? prefix str 0))
        ((prefix str start)
         (and (<= (string-length prefix) (- (string-length str) start))
              (string=? prefix (substring str start (+ start (string-length prefix))))))))


    (define (str-quote s)
      (let ((out (open-output-string)))
        (write s out)
        (get-output-string out)))


    (define-record-type <not-found-error>
      (make-not-found-error)
      not-found-error?)


    (define find
      (case-lambda
        ((match str) (find match str 0 (string-length str)))
        ((match str start) (find match str start (string-length str)))
        ((match str start end)
         (let loop ((i start))
           (cond ((>= i end) (raise (make-not-found-error)))
                 ((prefix? match str i) i)
                 (else (loop (+ 1 i))))))))


    (define (contains s substr)
      (if (string=? "" substr)
        #t
        (guard (e ((not-found-error? e) #f))
          (find substr s)
          #t)))


    (define (join sep strings)
      (apply string-append (intercalate sep strings)))


    (define (split s sep)
      (loop for s* = s then (string-copy s* (+ i (string-length sep)))
            for i = (guard (e ((not-found-error? e) (string-length s*)))
                      (find sep s*))
            collect (substring s* 0 i)
            while (< i (string-length s*))))))