Replace cl-case calls with cond

Users are reporting issues with `cl-case`, depending on the Emacs version and
build.

Author: plexus

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Unreleased
 
+- [#34](https://github.com/clojure-emacs/parseclj/pull/34) Replace `cl-case` with `cond`
+
 ## 1.0.4 (2021-09-30)
 
 - Provide parseclj-alist-merge, since we can't use `(map-merge 'alist)` yet in Emacs 25/26.

parseclj-ast.el

@@ -120,29 +120,29 @@ OPTIONS is an association list.  See `parseclj-parse' for more information
 on available options."
   (let* ((pos (map-elt opening-token :pos))
          (type (parseclj-lex-token-type opening-token))
-         (type (cl-case type
-                 (:lparen :list)
-                 (:lbracket :vector)
-                 (:lbrace :map)
-                 (t type))))
-    (cl-case type
-      (:root (cons (parseclj-ast-node :root pos :children children) stack))
-      (:discard stack)
-      (:tag (cons (parseclj-ast-node :tag
-                                     pos
-                                     :tag (intern (substring (map-elt opening-token :form) 1))
-                                     :children children)
-                  stack))
-      (:metadata (cons (parseclj-ast-node :with-meta
-                                          pos
-                                          :children children)
-                       stack))
-      (:map-prefix (cons (parseclj-alist-assoc (car children)
-                                               :map-prefix opening-token)
-                         stack))
-      (t (cons
-          (parseclj-ast-node type pos :children children)
-          stack)))))
+         (type (cond
+                ((eq :lparen type) :list)
+                ((eq :lbracket type) :vector)
+                ((eq :lbrace type) :map)
+                (t type))))
+    (cond
+     ((eq :root type) (cons (parseclj-ast-node :root pos :children children) stack))
+     ((eq :discard type) stack)
+     ((eq :tag type) (cons (parseclj-ast-node :tag
+                                              pos
+                                              :tag (intern (substring (map-elt opening-token :form) 1))
+                                              :children children)
+                           stack))
+     ((eq :metadata type) (cons (parseclj-ast-node :with-meta
+                                                   pos
+                                                   :children children)
+                                stack))
+     ((eq :map-prefix type) (cons (parseclj-alist-assoc (car children)
+                                                        :map-prefix opening-token)
+                                  stack))
+     (t (cons
+         (parseclj-ast-node type pos :children children)
+         stack)))))
 
 (defun parseclj-ast--reduce-branch-with-lexical-preservation (stack opening-token children options)
   "Reduce STACK with an AST branch node representing a collection of elements.
@@ -176,12 +176,12 @@ on available options."
 (defun parseclj-ast--unparse-collection (node)
   "Insert a string representation of the given AST branch NODE into buffer."
   (let* ((token-type (parseclj-ast-node-type node))
-         (delimiters (cl-case token-type
-                       (:root (cons "" ""))
-                       (:list (cons "(" ")"))
-                       (:vector (cons "[" "]"))
-                       (:set (cons "#{" "}"))
-                       (:map (cons "{" "}")))))
+         (delimiters (cond
+                      ((eq :root token-type) (cons "" ""))
+                      ((eq :list token-type) (cons "(" ")"))
+                      ((eq :vector token-type) (cons "[" "]"))
+                      ((eq :set token-type) (cons "#{" "}"))
+                      ((eq :map token-type) (cons "{" "}")))))
     (insert (car delimiters))
     (let ((nodes (alist-get ':children node)))
       (when-let (node (car nodes))

parseclj-lex.el

@@ -140,14 +140,15 @@ S goes through three transformations:
       (make-string 1 (string-to-number (substring x 2) 16)))
     (replace-regexp-in-string "\\\\[tbnrf'\"\\]"
                               (lambda (x)
-                                (cl-case (elt x 1)
-                                  (?t "\t")
-                                  (?f "\f")
-                                  (?\" "\"")
-                                  (?r "\r")
-                                  (?n "\n")
-                                  (?\\ "\\\\")
-                                  (t (substring x 1))))
+                                (let ((ch (elt x 1)))
+                                  (cond
+                                   ((eq ?t ch) "\t")
+                                   ((eq ?f ch) "\f")
+                                   ((eq ?\" ch) "\"")
+                                   ((eq ?r ch) "\r")
+                                   ((eq ?n ch) "\n")
+                                   ((eq ?\\ ch) "\\\\")
+                                   (t (substring x 1)))))
                               (substring s 1 -1)))))
 
 (defun parseclj-lex--character-value (c)
@@ -164,16 +165,17 @@ S goes through three transformations:
 
 (defun parseclj-lex--leaf-token-value (token)
   "Parse the given leaf TOKEN to an Emacs Lisp value."
-  (cl-case (parseclj-lex-token-type token)
-    (:number (string-to-number (alist-get :form token)))
-    (:nil nil)
-    (:true t)
-    (:false nil)
-    (:symbol (intern (alist-get :form token)))
-    (:keyword (intern (alist-get :form token)))
-    (:string (parseclj-lex--string-value (alist-get :form token)))
-    (:character (parseclj-lex--character-value (alist-get :form token)))
-    (:symbolic-value (intern (substring (alist-get :form token) 2)))))
+  (let ((token-type (parseclj-lex-token-type token)))
+    (cond
+     ((eq :number token-type) (string-to-number (alist-get :form token)))
+     ((eq :nil token-type) nil)
+     ((eq :true token-type) t)
+     ((eq :false token-type) nil)
+     ((eq :symbol token-type) (intern (alist-get :form token)))
+     ((eq :keyword token-type) (intern (alist-get :form token)))
+     ((eq :string token-type) (parseclj-lex--string-value (alist-get :form token)))
+     ((eq :character token-type) (parseclj-lex--character-value (alist-get :form token)))
+     ((eq :symbolic-value token-type) (intern (substring (alist-get :form token) 2))))))
 
 ;; Stream tokenization
 

parseclj-parser.el

@@ -43,18 +43,19 @@ can be handled with `condition-case'."
 
 (defun parseclj--find-opening-token (stack closing-token)
   "Scan STACK for an opening-token matching CLOSING-TOKEN."
-  (cl-case (parseclj-lex-token-type closing-token)
-    (:rparen (parseclj-lex-token-type
-              (seq-find (lambda (token)
-                          (member (parseclj-lex-token-type token)
-                                  '(:lparen :lambda)))
-                        stack)))
-    (:rbracket :lbracket)
-    (:rbrace (parseclj-lex-token-type
-              (seq-find (lambda (token)
-                          (member (parseclj-lex-token-type token)
-                                  '(:lbrace :set)))
-                        stack)))))
+  (let ((token-type (parseclj-lex-token-type closing-token)))
+    (cond
+     ((eq :rparen token-type) (parseclj-lex-token-type
+                               (seq-find (lambda (token)
+                                           (member (parseclj-lex-token-type token)
+                                                   '(:lparen :lambda)))
+                                         stack)))
+     ((eq :rbracket token-type) :lbracket)
+     ((eq :rbrace token-type) (parseclj-lex-token-type
+                               (seq-find (lambda (token)
+                                           (member (parseclj-lex-token-type token)
+                                                   '(:lbrace :set)))
+                                         stack))))))
 
 (defun parseclj--reduce-coll (stack closing-token reduce-branch options)
   "Reduce collection based on the top of the STACK and a CLOSING-TOKEN.