@@ -35,7 +35,8 @@

                 (simple-string (char= (aref string end-idx) char))

                 (string (char= (aref string end-idx) char)))

           (setf (aref parts target-spot)

-                (make-array (- end-idx start-idx) :displaced-to string :displaced-index-offset start-idx

+                (make-array (- end-idx start-idx)

+                            :displaced-to string :displaced-index-offset start-idx

                             :element-type 'character))

           (incf target-spot)

           (setf start-idx (1+ end-idx))

@@ -79,7 +80,7 @@

                0))

          (find-pos (start-pos)

            (declare (optimize #+dev (debug 3) #+dev (speed 0) #+dev (space 0)

-                     #-dev (speed 3) #-dev(space 2))

+                              #-dev (speed 3) #-dev(space 2))

                     (type array-index start-pos))

            (etypecase test

              (function (position divider string :start start-pos :test test))

@@ -90,18 +91,18 @@

       (setf count (count-splits string)))

     (check-type count array-length)

-    (let ((parts (make-array (max count 1) :fill-pointer 0))

+    (let ((parts (make-array (max (1+ count) 1) :fill-pointer 0))

           (start-pos (the fixnum 0)))

       (declare (dynamic-extent start-pos))

       (prog1 parts

         (loop 

-           for end-pos = (find-pos start-pos)

-           while end-pos 

-           do

+          for end-pos = (find-pos start-pos)

+          while end-pos 

+          do

              (vector-push (subseq string start-pos end-pos) parts)

              (setf start-pos (1+ end-pos))

-           while (< (length parts) (1- count))

-           finally

+          while (< (length parts) count)

+          finally

              (cond ((or (and end-pos count)

                         (< start-pos (length string)))

                     (vector-push (subseq string start-pos)

@@ -146,16 +147,16 @@

                              :fill-pointer 0))

           (start-pos 0))

       (loop 

-         for end-pos = (typecase search-test

-                         (function (%search-with-test start-pos search-test))

-                         (null (%search start-pos)))

-         do

+        for end-pos = (typecase search-test

+                        (function (%search-with-test start-pos search-test))

+                        (null (%search start-pos)))

+        do

            (vector-push-extend (subseq string start-pos end-pos) parts) 

            (incf (the array-length num-parts))

-         while end-pos

-         do (setf start-pos (the array-length (+ pattern-length end-pos)))

-         until (and count (>= (1+ num-parts) count))

-         finally

+        while end-pos

+        do (setf start-pos (the array-length (+ pattern-length end-pos)))

+        until (and count (>= num-parts count))

+        finally

            (when (and count end-pos)

              (vector-push-extend (subseq string (+ pattern-length end-pos)) parts))

            (return parts)))))

@@ -10,10 +10,18 @@

     (st:should be vos-equal

                #("a" "a" "a" "a")

                (%split-on-string "b" "abababa" :test #'string-equal)))

-  (st:deftest string-split-as-expected-with-count ()

+  (st:deftest string-split-as-expected-with-count-1 ()

     (st:should be vos-equal

                #("a" "b c d")

+               (%split-on-string " " "a b c d" :count 1)))

+  (st:deftest string-split-as-expected-with-count-2 ()

+    (st:should be vos-equal

+               #("a" "b" "c d")

                (%split-on-string " " "a b c d" :count 2)))

+  (st:deftest string-split-as-expected-with-count-3 ()

+    (st:should be vos-equal

+               #("a" "b" "c" "d")

+               (%split-on-string " " "a b c d" :count 3)))

   (st:deftest string-split-as-expected-with-consecutive-sep ()

     (st:should be vos-equal

                #("a" "b" "" "c" "d")

@@ -47,10 +55,18 @@

     (st:should be vos-equal

                #("a" "a" "a" "a")

                (%split-on-char #\b "abababa" :test #'char-equal)))

-  (st:deftest char-split-as-expected-with-count ()

+  (st:deftest char-split-as-expected-with-count-1 ()

     (st:should be vos-equal

                #("a" "b c d")

+               (%split-on-char #\space "a b c d" :count 1)))

+  (st:deftest char-split-as-expected-with-count-2 ()

+    (st:should be vos-equal

+               #("a" "b" "c d")

                (%split-on-char #\space "a b c d" :count 2)))

+  (st:deftest char-split-as-expected-with-count-3 ()

+    (st:should be vos-equal

+               #("a" "b" "c" "d")

+               (%split-on-char #\space "a b c d" :count 3)))

   (st:deftest char-split-as-expected-with-consecutive-sep ()

     (st:should be vos-equal

                #("a" "b" "" "c" "d")

@@ -82,3 +98,30 @@

                #("Bacon")

                (%split-on-char #\. "Bacon")))

   )

+

+(progn

+  (unintern 'char-split-as-expected)

+  (unintern 'char-split-as-expected-with-consecutive-sep)

+  (unintern 'char-split-as-expected-with-test)

+  (unintern 'char-split-as-expected-with-count)

+  (unintern 'char-split-as-expected-with-count-1)

+  (unintern 'char-split-as-expected-with-count-2)

+  (unintern 'char-split-as-expected-with-count-3)

+  (unintern 'char-split-as-expected-with-leading-and-trailing-sep)

+  (unintern 'char-split-as-expected-with-leading-sep)

+  (unintern 'char-split-as-expected-with-trailing-sep)

+  (unintern 'string-split-as-expected)

+  (unintern 'string-split-as-expected-with-consecutive-sep)

+  (unintern 'string-split-as-expected-with-test)

+  (unintern 'string-split-as-expected-with-count)

+  (unintern 'string-split-as-expected-with-count-1)

+  (unintern 'string-split-as-expected-with-count-2)

+  (unintern 'string-split-as-expected-with-count-3)

+  (unintern 'string-split-as-expected-with-leading-and-trailing-sep)

+  (unintern 'string-split-as-expected-with-leading-sep)

+  (unintern 'string-split-as-expected-with-test)

+  (unintern 'string-split-as-expected-with-trailing-sep)

+  (unintern 'string-split-empty-string-as-expected)

+  (unintern 'string-split-multichar-as-expected)

+  (unintern 'CHAR-SPLIT-NO-SEP-RETURNS-VEC-WITH-CONTENTS)

+  (unintern 'CHAR-SPLIT-EMPTY-STRING-AS-EXPECTED))