Convert functions to use more standard CL libs

mailfilter-parse.asd

   :license "BSD 3-clause"
   :depends-on (#:cl-ppcre
                #:alexandria
-               #:mel-base)
+               #:mel-base
+               #:split-sequence)
   :serial t
   :components ((:file "package")
                (:file "mailfilter-parse")))

mailfilter-parse.lisp

 (defvar *commands* '("to"))
 (defvar *maildir* nil)
 
-; Thanks to http://cl-cookbook.sourceforge.net/strings.html#manip
-(defun replace-all (string part replacement &key (test #'char=))
-  "Returns a new string in which all the occurences of the part
-   is replaced with replacement."
-  (with-output-to-string (out)
-    (loop with part-length = (length part)
-       for old-pos = 0 then (+ pos part-length)
-       for pos = (search part string
-                         :start2 old-pos
-                         :test test)
-       do (write-string string out
-                        :start old-pos
-                        :end (or pos (length string)))
-       when pos do (write-string replacement out)
-       while pos)))
-
-; This function is pretty ugly but I was tired when I wrote it and just wanted it to work.
-; TODO: Clean this up
+;; This function is pretty ugly but I was tired when I wrote it and just wanted it to work.
+;; TODO: Clean this up
 (defun split-quoted (str)
   (let ((my-list nil)
         (my-string (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t))
 (defun check-start (line expected seperator)
   (if (or (empty-string? line) (empty-string? seperator))
       nil
-      (string= expected (first (split line seperator)))))
+      (string= expected (first (split-sequence:split-sequence seperator line)))))
 
 (defun test-for-maildir (line)
   (check-start line "MAILDIR" "="))
      until (or (eq line 'eof) (funcall test-func line))))
 
 (defun convert-maildir-value (value)
-  (remove #\" (replace-all value "${HOME}" (to-string (user-homedir-pathname)))))
+  (remove #\" (cl-ppcre:regex-replace-all "${HOME}" value (user-homedir-pathname))))
 
 (defun set-maildir (line hash)
-  (let ((maildir (convert-maildir-value (car (last (split line "="))))))
-    (sethash "maildir" hash maildir)
+  (let ((maildir (convert-maildir-value (car (last (split-sequence:split-sequence "=" line))))))
+    (setf (gethash "maildir" hash) maildir)
     (setf *maildir* maildir)))
 
 (defun parse-line (s line hash)
 
 (defun clean-line (line)
   (let ((cleaned-line (string-trim '(#\Space #\Tab) line)))
-    (replace-all cleaned-line "${MAILDIR}" *maildir*)))
+    (cl-ppcre:regex-replace-all "${MAILDIR}" cleaned-line *maildir*)))
 
 (defun hash-add-command (line hash)
   (let* ((cleaned-line (clean-line line))
          (line-list (split-quoted cleaned-line)))
-    (sethash "command" hash (first line-list))
-    (sethash "args" hash (subseq line-list 1))
+    (setf (gethash "command" hash) (first line-list))
+    (setf (gethash "args" hash) (subseq line-list 1))
     hash))
 
 (defun get-regex (line)
-  (second (split line "/")))
+  (second (split-sequence:split-sequence "/" line)))
 
 (defun make-regex-hash (regex)
   (let ((regex-hash (make-hash-table :test 'equal)))
-    (sethash "regex" regex-hash regex)
+    (setf (gethash "regex" regex-hash) regex)
     regex-hash))
 
 (defun parse-if-line (line hash)
   (if (test-for-if line)
       (let* ((regex (get-regex line))
              (regex-hash (make-regex-hash regex)))
-        (sethash "patterns" hash (append (gethash "patterns" hash) (list regex-hash)))
+        (setf (gethash "patterns" hash) (append (gethash "patterns" hash) (list regex-hash)))
         regex-hash)))
 
 (defun parse-inner-if-line (s line hash)
+  (declare (ignore s) )
   (if (test-for-command line)
       (hash-add-command line hash)))
 
 (defun read-mailfilter-file (file)
   (let ((hash (make-hash-table :test 'equal)))
     (with-open-file (s file)
-      (loop-file-until s (lambda (x) nil)  #'parse-line hash))
+      (loop-file-until s (lambda (x) (declare (ignore x)))  #'parse-line hash))
     hash))