Split a string without consuming separators?

Question

I frequently need to split strings, while keeping the separator. Researching the elisp manual, I am not finding a way to split a string according to a separator, without consuming the separator itself.

For example, split-string splits a given string into substrings based on the regular expression separators, but the substrings lose the separator:

(split-string "* one * two * three" "\*")

returns:

("" " one " " two " " three")

I could use s-slice-at, from @magnars s.el

(s-slice-at "\*" "* one * two * three")

("* one " "* two " "* three")

I could also try to rewrite split-string myself. Still, I was wondering if there is a built-in way to do it as part of Emacs core?

If not, could somebody please point to a good way to do that properly?

Answer 1

Perhaps a shorter example, using cl library:

(defun chop (string separator)
  (cl-loop with seplen = (length separator)
           with len = (length string)
           with start = 0
           with next = seplen
           for end = (or (cl-search separator string :start2 next) len)
           for chunk = (substring string start end)
           collect chunk
           while (< end len)
           do (setf start end next (+ seplen end))))

(chop "* one * two * three" "*")
("* one " "* two " "* three")

But delimiters are strings, not regular expressions.

Answer 2

Here's some code for you. This is a slightly modified split-string. I've removed trim option for simplicity and added keep-sep option. The diff is basically 2 lines, so you could say that this code is idiomatic:

(defun split-string (string &optional separators omit-nulls keep-sep)
  "Split STRING into substrings bounded by matches for SEPARATORS."
  (let* ((keep-nulls (not (if separators omit-nulls t)))
         (rexp (or separators split-string-default-separators))
         (start 0)
         this-start this-end
         notfirst
         (list nil)
         (push-one
          (lambda ()
            (when (or keep-nulls (< this-start this-end))
              (let ((this (substring string this-start this-end)))
                (when (or keep-nulls (> (length this) 0))
                  (push this list)))))))
    (while (and (string-match
                 rexp string
                 (if (and notfirst
                          (= start (match-beginning 0))
                          (< start (length string)))
                     (1+ start) start))
                (< start (length string)))
      (setq notfirst t)
      (setq this-start start this-end (match-beginning 0)
            start (match-end 0))
      (funcall push-one)
      (when keep-sep
        (push (match-string 0 string) list)))
    (setq this-start start this-end (length string))
    (funcall push-one)
    (nreverse list)))

(split-string "* one * two * three" "\*" t t)
;; -> ("*" " one " "*" " two " "*" " three")