Always use plists to represent nrepl requests

Author: alexander-yakushev

cider-client.el

@@ -254,7 +254,7 @@ you need to encode it as the following plist:
   :group 'cider
   :package-version '(cider . "1.1.0"))
 
-(defun cider--nrepl-format-code-request-map (&optional format-options)
+(defun cider--nrepl-format-code-request-options (&optional format-options)
   "Map to merge into requests that require code formatting.
 If non-nil, FORMAT-OPTIONS specifies the options cljfmt will use to format
 the code.  See `cider-format-code-options' for details."
@@ -271,15 +271,11 @@ the code.  See `cider-format-code-options' for details."
                                (map-pairs)
                                (seq-mapcat #'identity)
                                (apply #'nrepl-dict)))))
-      (thread-last
-        (map-merge 'list
-                   (when indents-dict
-                     `(("indents" ,indents-dict)))
-                   (when alias-map-dict
-                     `(("alias-map" ,alias-map-dict))))
-        (map-pairs)
-        (seq-mapcat #'identity)
-        (apply #'nrepl-dict)))))
+      (nrepl-dict
+       `(,@(when indents-dict
+             `("indents" ,indents-dict))
+         ,@(when alias-map-dict
+             `("alias-map" ,alias-map-dict)))))))
 
 (defcustom cider-print-fn 'pprint
   "Sets the function to use for printing.
@@ -388,7 +384,7 @@ The result will be a string."
          (result (cdr (assoc printer (cadr (assoc name cider--print-options-mapping))))))
     (symbol-name (or result name))))
 
-(defun cider--nrepl-print-request-map (&optional right-margin)
+(defun cider--nrepl-print-request-plist (&optional right-margin)
   "Map to merge into requests that require pretty-printing.
 RIGHT-MARGIN specifies the maximum column-width of the printed result, and
 is included in the request if non-nil."
@@ -400,35 +396,29 @@ is included in the request if non-nil."
                           (map-pairs)
                           (seq-mapcat #'identity)
                           (apply #'nrepl-dict))))
-    (map-merge 'list
-               `(("nrepl.middleware.print/stream?" "1"))
-               (when cider-print-fn
-                 `(("nrepl.middleware.print/print" ,(cider--print-fn))))
-               (when cider-print-quota
-                 `(("nrepl.middleware.print/quota" ,cider-print-quota)))
-               (when cider-print-buffer-size
-                 `(("nrepl.middleware.print/buffer-size" ,cider-print-buffer-size)))
-               (unless (nrepl-dict-empty-p print-options)
-                 `(("nrepl.middleware.print/options" ,print-options))))))
-
-(defun cider--nrepl-pr-request-map ()
+    `("nrepl.middleware.print/stream?" "1"
+      ,@(when cider-print-fn
+          `("nrepl.middleware.print/print" ,(cider--print-fn)))
+      ,@(when cider-print-quota
+          `("nrepl.middleware.print/quota" ,cider-print-quota))
+      ,@(when cider-print-buffer-size
+          `("nrepl.middleware.print/buffer-size" ,cider-print-buffer-size))
+      ,@(unless (nrepl-dict-empty-p print-options)
+          `("nrepl.middleware.print/options" ,print-options)))))
+
+(defun cider--nrepl-pr-request-plist ()
   "Map to merge into requests that do not require pretty printing."
   (let ((print-options (thread-last
                          cider-print-options
                          (map-pairs)
                          (seq-mapcat #'identity)
                          (apply #'nrepl-dict))))
-    (map-merge 'list
-               `(("nrepl.middleware.print/print" "cider.nrepl.pprint/pr")
-                 ("nrepl.middleware.print/stream?" nil))
-               (unless (nrepl-dict-empty-p print-options)
-                 `(("nrepl.middleware.print/options" ,print-options)))
-               (when cider-print-quota
-                 `(("nrepl.middleware.print/quota" ,cider-print-quota))))))
-
-(defun cider--nrepl-content-type-map ()
-  "Map to be merged into an eval request to make it use content-types."
-  '(("content-type" "true")))
+    `("nrepl.middleware.print/print" "cider.nrepl.pprint/pr"
+      "nrepl.middleware.print/stream?" nil
+      ,@(unless (nrepl-dict-empty-p print-options)
+          `("nrepl.middleware.print/options" ,print-options))
+      ,@(when cider-print-quota
+          `("nrepl.middleware.print/quota" ,cider-print-quota)))))
 
 (defun cider-tooling-eval (input callback &optional ns connection)
   "Send the request INPUT to CONNECTION and register the CALLBACK.
@@ -877,7 +867,7 @@ The result entries are relative to the classpath."
   "Perform nREPL \"format-code\" op with CODE.
 FORMAT-OPTIONS is an optional configuration map for cljfmt."
   (let* ((request `("op" "format-code"
-                    "options" ,(cider--nrepl-format-code-request-map format-options)
+                    "options" ,(cider--nrepl-format-code-request-options format-options)
                     "code" ,code))
          (response (cider-nrepl-send-sync-request request))
          (err (nrepl-dict-get response "err")))
@@ -889,12 +879,9 @@ FORMAT-OPTIONS is an optional configuration map for cljfmt."
 
 (defun cider-sync-request:format-edn (edn right-margin)
   "Perform \"format-edn\" op with EDN and RIGHT-MARGIN."
-  (let* ((request (thread-last
-                    (map-merge 'list
-                               `(("op" "format-edn")
-                                 ("edn" ,edn))
-                               (cider--nrepl-print-request-map right-margin))
-                    (seq-mapcat #'identity)))
+  (let* ((request `("op" "format-edn"
+                    "edn" ,edn
+                    ,@(cider--nrepl-print-request-plist right-margin)))
          (response (cider-nrepl-send-sync-request request))
          (err (nrepl-dict-get response "err")))
     (when err

cider-debug.el

@@ -143,11 +143,8 @@ configure `cider-debug-prompt' instead."
 (defun cider--debug-init-connection ()
   "Initialize a connection with the cider.debug middleware."
   (cider-nrepl-send-request
-   (thread-last
-     (map-merge 'list
-                '(("op" "init-debugger"))
-                (cider--nrepl-print-request-map fill-column))
-     (seq-mapcat #'identity))
+   `("op" "init-debugger"
+     ,@(cider--nrepl-print-request-plist fill-column))
    #'cider--debug-response-handler))
 
 

cider-eval.el

@@ -354,11 +354,8 @@ into a new error buffer."
   ;; Causes are returned as a series of messages, which we aggregate in `causes'
   (let (causes ex-phase)
     (cider-nrepl-send-request
-     (thread-last
-       (map-merge 'list
-                  '(("op" "analyze-last-stacktrace"))
-                  (cider--nrepl-print-request-map fill-column))
-       (seq-mapcat #'identity))
+     `("op" "analyze-last-stacktrace"
+       ,@(cider--nrepl-print-request-plist fill-column))
      (lambda (response)
        (nrepl-dbind-response response (phase)
          (when phase
@@ -691,13 +688,12 @@ REPL buffer.  This is controlled via
                        (cider-current-repl))))
       (when (cider-nrepl-op-supported-p "analyze-last-stacktrace" conn)
         (let ((nrepl-sync-request-timeout 4)) ;; ensure that this feature cannot possibly create an overly laggy UX
-          (when-let* ((result (nrepl-send-sync-request (thread-last (map-merge 'list
-                                                                               '(("op" "analyze-last-stacktrace"))
-                                                                               (cider--nrepl-print-request-map fill-column))
-                                                                    (seq-mapcat #'identity))
-                                                       conn
-                                                       'abort-on-input ;; favor responsiveness over this feature, in case something went wrong.
-                                                       )))
+          (when-let* ((result (nrepl-send-sync-request
+                               `("op" "analyze-last-stacktrace"
+                                 ,@(cider--nrepl-print-request-plist fill-column))
+                               conn
+                               'abort-on-input ;; favor responsiveness over this feature, in case something went wrong.
+                               )))
             (nrepl-dict-get result "phase")))))))
 
 (defcustom cider-inline-error-message-function #'cider--shorten-error-message
@@ -1026,11 +1022,12 @@ API.  Most other interactive eval functions should rely on this function.
 If CALLBACK is nil use `cider-interactive-eval-handler'.
 BOUNDS, if non-nil, is a list of two numbers marking the start and end
 positions of FORM in its buffer.
-ADDITIONAL-PARAMS is a map to be merged into the request message.
+ADDITIONAL-PARAMS is a plist to be merged into the request message.
 
 If `cider-interactive-eval-override' is a function, call it with the same
 arguments and only proceed with evaluation if it returns nil."
   (let ((form  (or form (apply #'buffer-substring-no-properties bounds)))
+        (additional-params (nrepl--alist-to-plist additional-params))
         (start (car-safe bounds))
         (end   (car-safe (cdr-safe bounds))))
     (when (and start end)
@@ -1057,7 +1054,7 @@ arguments and only proceed with evaluation if it returns nil."
            (if (cider-ns-form-p form) "user" (cider-current-ns))
            (when start (line-number-at-pos start))
            (when start (cider-column-number-at-pos start))
-           (seq-mapcat #'identity additional-params)
+           additional-params
            connection))))))
 
 (defun cider-eval-region (start end)
@@ -1066,7 +1063,7 @@ arguments and only proceed with evaluation if it returns nil."
   (cider-interactive-eval nil
                           nil
                           (list start end)
-                          (cider--nrepl-pr-request-map)))
+                          (cider--nrepl-pr-request-plist)))
 
 (defun cider-eval-last-sexp (&optional output-to-current-buffer)
   "Evaluate the expression preceding point.
@@ -1076,7 +1073,7 @@ buffer."
   (cider-interactive-eval nil
                           (when output-to-current-buffer (cider-eval-print-handler))
                           (cider-last-sexp 'bounds)
-                          (cider--nrepl-pr-request-map)))
+                          (cider--nrepl-pr-request-plist)))
 
 (defun cider-eval-last-sexp-and-replace ()
   "Evaluate the expression preceding point and replace it with its result."
@@ -1091,7 +1088,7 @@ buffer."
     (cider-interactive-eval last-sexp
                             (cider-eval-print-handler)
                             nil
-                            (cider--nrepl-pr-request-map))))
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider-eval-list-at-point (&optional output-to-current-buffer)
   "Evaluate the list (eg.  a function call, surrounded by parens) around point.
@@ -1118,7 +1115,7 @@ buffer."
     (cider-interactive-eval tapped-form
                             (when output-to-current-buffer (cider-eval-print-handler))
                             nil
-                            (cider--nrepl-pr-request-map))))
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider-tap-sexp-at-point (&optional output-to-current-buffer)
   "Evaluate and tap the expression around point.
@@ -1167,7 +1164,7 @@ When GUESS is non-nil, attempt to extract the context from parent let-bindings."
     (cider-interactive-eval code
                             nil
                             bounds
-                            (cider--nrepl-pr-request-map))))
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider-eval-last-sexp-in-context (guess)
   "Evaluate the preceding sexp in user-supplied context.
@@ -1206,7 +1203,7 @@ With the prefix arg INSERT-BEFORE, insert before the form, otherwise afterwards.
                              (set-marker (make-marker) insertion-point)
                              cider-comment-prefix)
                             bounds
-                            (cider--nrepl-pr-request-map))))
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider-pprint-form-to-comment (form-fn insert-before)
   "Evaluate the form selected by FORM-FN and insert result as comment.
@@ -1236,7 +1233,7 @@ If INSERT-BEFORE is non-nil, insert before the form, otherwise afterwards."
                              cider-comment-continued-prefix
                              comment-postfix)
                             bounds
-                            (cider--nrepl-print-request-map fill-column))))
+                            (cider--nrepl-print-request-plist fill-column))))
 
 (defun cider-pprint-eval-last-sexp-to-comment (&optional insert-before)
   "Evaluate the last sexp and insert result as comment.
@@ -1290,13 +1287,13 @@ honoring SWITCH-TO-REPL, REQUEST-MAP."
   "Evaluate the expression preceding point and insert its result in the REPL.
 If invoked with a PREFIX argument, switch to the REPL buffer."
   (interactive "P")
-  (cider--eval-last-sexp-to-repl prefix (cider--nrepl-pr-request-map)))
+  (cider--eval-last-sexp-to-repl prefix (cider--nrepl-pr-request-plist)))
 
 (defun cider-pprint-eval-last-sexp-to-repl (&optional prefix)
   "Evaluate expr before point and insert its pretty-printed result in the REPL.
 If invoked with a PREFIX argument, switch to the REPL buffer."
   (interactive "P")
-  (cider--eval-last-sexp-to-repl prefix (cider--nrepl-print-request-map fill-column)))
+  (cider--eval-last-sexp-to-repl prefix (cider--nrepl-print-request-plist fill-column)))
 
 (defun cider-eval-print-last-sexp (&optional pretty-print)
   "Evaluate the expression preceding point.
@@ -1307,8 +1304,8 @@ With an optional PRETTY-PRINT prefix it pretty-prints the result."
                           (cider-eval-print-handler)
                           (cider-last-sexp 'bounds)
                           (if pretty-print
-                              (cider--nrepl-print-request-map fill-column)
-                            (cider--nrepl-pr-request-map))))
+                              (cider--nrepl-print-request-plist fill-column)
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider--pprint-eval-form (form)
   "Pretty print FORM in popup buffer."
@@ -1319,7 +1316,7 @@ With an optional PRETTY-PRINT prefix it pretty-prints the result."
       (cider-interactive-eval (when (stringp form) form)
                               handler
                               (when (consp form) form)
-                              (cider--nrepl-print-request-map fill-column)))))
+                              (cider--nrepl-print-request-plist fill-column)))))
 
 (defun cider-pprint-eval-last-sexp (&optional output-to-current-buffer)
   "Evaluate the sexp preceding point and pprint its value.
@@ -1383,7 +1380,7 @@ command `cider-debug-defun-at-point'."
                               (concat "#dbg\n" (cider-defun-at-point)))
                             nil
                             (cider-defun-at-point 'bounds)
-                            (cider--nrepl-pr-request-map))))
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider--insert-closing-delimiters (code)
   "Closes all open parenthesized or bracketed expressions of CODE."
@@ -1415,7 +1412,7 @@ buffer.  It constructs an expression to eval in the following manner:
                             (when output-to-current-buffer
                               (cider-eval-print-handler))
                             (list beg-of-defun (point))
-                            (cider--nrepl-pr-request-map))))
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider--matching-delimiter (delimiter)
   "Get the matching (opening/closing) delimiter for DELIMITER."
@@ -1446,7 +1443,7 @@ buffer.  It constructs an expression to eval in the following manner:
                             (when output-to-current-buffer
                               (cider-eval-print-handler))
                             (list beg-of-sexp (point))
-                            (cider--nrepl-pr-request-map))))
+                            (cider--nrepl-pr-request-plist))))
 
 (defun cider-pprint-eval-defun-at-point (&optional output-to-current-buffer)
   "Evaluate the \"top-level\" form at point and pprint its value.
@@ -1485,7 +1482,7 @@ If VALUE is non-nil, it is inserted into the minibuffer as initial input."
         (cider-interactive-eval form
                                 nil
                                 nil
-                                (cider--nrepl-pr-request-map))))))
+                                (cider--nrepl-pr-request-plist))))))
 
 (defun cider-read-and-eval-defun-at-point ()
   "Insert the toplevel form at point in the minibuffer and output its result.

cider-log.el

@@ -282,13 +282,11 @@ It will not be used if the package hasn't been installed."
   "Format the log EVENT from the APPENDER of the log FRAMEWORK."
   (cider-ensure-op-supported "cider/log-format-event")
   (thread-first
-    (seq-mapcat #'identity
-                (map-merge 'list
-                           (cider--nrepl-print-request-map fill-column)
-                           `(("op" "cider/log-format-event")
-                             ("framework" ,(cider-log-framework-id framework))
-                             ("appender" ,(cider-log-appender-id appender))
-                             ("event" ,(cider-log-event-id event)))))
+    `("op" "cider/log-format-event"
+      "framework" ,(cider-log-framework-id framework)
+      "appender" ,(cider-log-appender-id appender)
+      "event" ,(cider-log-event-id event)
+      ,@(cider--nrepl-print-request-plist fill-column))
     (cider-nrepl-send-sync-request)
     (nrepl-dict-get "cider/log-format-event")))
 

cider-ns.el

@@ -237,15 +237,14 @@ Its behavior is controlled by `cider-ns-save-files-on-refresh' and
 (defun cider-ns--reload-op (op-name)
   "Return the reload operation to use.
 Based on OP-NAME and the value of cider-ns-code-reload-tool defcustom."
-  (list "op"
-        (if (eq cider-ns-code-reload-tool 'tools.namespace)
-            (cond ((string= op-name "reload")       "refresh")
-                  ((string= op-name "reload-all")   "refresh-all")
-                  ((string= op-name "reload-clear") "refresh-clear"))
+  (if (eq cider-ns-code-reload-tool 'tools.namespace)
+      (cond ((string= op-name "reload")       "refresh")
+            ((string= op-name "reload-all")   "refresh-all")
+            ((string= op-name "reload-clear") "refresh-clear"))
 
-          (cond ((string= op-name "reload")       "cider.clj-reload/reload")
-                ((string= op-name "reload-all")   "cider.clj-reload/reload-all")
-                ((string= op-name "reload-clear") "cider.clj-reload/reload-clear")))))
+    (cond ((string= op-name "reload")       "cider.clj-reload/reload")
+          ((string= op-name "reload-all")   "cider.clj-reload/reload-all")
+          ((string= op-name "reload-clear") "cider.clj-reload/reload-clear"))))
 
 ;;;###autoload
 (defun cider-ns-reload (&optional prompt)
@@ -317,17 +316,14 @@ refresh functions (defined in `cider-ns-refresh-before-fn' and
                                           nil
                                           t))
           (when clear?
-            (cider-nrepl-send-sync-request (cider-ns--reload-op "reload-clear") conn))
+            (cider-nrepl-send-sync-request `("op" ,(cider-ns--reload-op "reload-clear")) conn))
           (cider-nrepl-send-request
-           (thread-last
-             (map-merge 'list
-                        `(,(cider-ns--reload-op (if all? "reload-all" "reload")))
-                        (cider--nrepl-print-request-map fill-column)
-                        (when (and (not inhibit-refresh-fns) cider-ns-refresh-before-fn)
-                          `(("before" ,cider-ns-refresh-before-fn)))
-                        (when (and (not inhibit-refresh-fns) cider-ns-refresh-after-fn)
-                          `(("after" ,cider-ns-refresh-after-fn))))
-             (seq-mapcat #'identity))
+           `("op" ,(cider-ns--reload-op (if all? "reload-all" "reload"))
+             ,@(cider--nrepl-print-request-plist fill-column)
+             ,@(when (and (not inhibit-refresh-fns) cider-ns-refresh-before-fn)
+                 `("before" ,cider-ns-refresh-before-fn))
+             ,@(when (and (not inhibit-refresh-fns) cider-ns-refresh-after-fn)
+                 `("after" ,cider-ns-refresh-after-fn)))
            (lambda (response)
              (cider-ns-refresh--handle-response response log-buffer))
            conn))))))

cider-repl.el

@@ -290,9 +290,8 @@ Run CALLBACK once the evaluation is complete."
   "Evaluate `cider-repl-init-code' in the current REPL.
 Run CALLBACK once the evaluation is complete."
   (interactive)
-  (let* ((request (map-merge 'hash-table
-                             (cider--repl-request-map fill-column)
-                             '(("inhibit-cider-middleware" "true")))))
+  (let* ((request `(,@(cider--repl-request-plist)
+                    "inhibit-cider-middleware" "true")))
     (cider-nrepl-request:eval
      ;; Ensure we evaluate _something_ so the initial namespace is correctly set
      (thread-first (or cider-repl-init-code '("nil"))
@@ -301,10 +300,7 @@ Run CALLBACK once the evaluation is complete."
      nil
      (line-number-at-pos (point))
      (cider-column-number-at-pos (point))
-     (thread-last
-       request
-       (map-pairs)
-       (seq-mapcat #'identity)))))
+     request)))
 
 (defun cider-repl-init (buffer &optional callback)
   "Initialize the REPL in BUFFER.
@@ -1083,15 +1079,13 @@ and responding to them.")
      (lambda (buffer warning)
        (cider-repl-emit-stderr buffer warning)))))
 
-(defun cider--repl-request-map (right-margin)
-  "Map to be merged into REPL eval requests.
-RIGHT-MARGIN is as in `cider--nrepl-print-request-map'."
-  (map-merge 'hash-table
-             (cider--nrepl-print-request-map right-margin)
-             (unless cider-repl-use-pretty-printing
-               '(("nrepl.middleware.print/print" "cider.nrepl.pprint/pr")))
-             (when cider-repl-use-content-types
-               (cider--nrepl-content-type-map))))
+(defun cider--repl-request-plist ()
+  "Plist to be merged into REPL eval requests."
+  `(,@(cider--nrepl-print-request-plist fill-column)
+    ,@(unless cider-repl-use-pretty-printing
+        `("nrepl.middleware.print/print" "cider.nrepl.pprint/pr"))
+    ,@(when cider-repl-use-content-types
+        `("content-type" "true"))))
 
 (defun cider-repl--send-input (&optional newline)
   "Go to the end of the input and send the current input.
@@ -1132,10 +1126,7 @@ If NEWLINE is true then add a newline at the end of the input."
          (cider-current-ns)
          (line-number-at-pos input-start)
          (cider-column-number-at-pos input-start)
-         (thread-last
-           (cider--repl-request-map fill-column)
-           (map-pairs)
-           (seq-mapcat #'identity)))))))
+         (cider--repl-request-plist))))))
 
 (defun cider-repl-return (&optional end-of-input)
   "Evaluate the current input string, or insert a newline.

cider-stacktrace.el

@@ -931,14 +931,6 @@ through the `cider-stacktrace-suppressed-errors' variable."
   "Return the Cider NREPL op to analyze STACKTRACE."
   (list "op" "analyze-stacktrace" "stacktrace" stacktrace))
 
-(defun cider-stacktrace--stacktrace-request (stacktrace)
-  "Return the Cider NREPL request to analyze STACKTRACE."
-  (thread-last
-    (map-merge 'list
-               (list (cider-stacktrace--analyze-stacktrace-op stacktrace))
-               (cider--nrepl-print-request-map fill-column))
-    (seq-mapcat #'identity)))
-
 (defun cider-stacktrace--analyze-render (causes)
   "Render the CAUSES of the stacktrace analysis result."
   (let ((buffer (get-buffer-create cider-error-buffer)))
@@ -953,7 +945,9 @@ through the `cider-stacktrace-suppressed-errors' variable."
     (set-text-properties 0 (length stacktrace) nil stacktrace))
   (let (causes)
     (cider-nrepl-send-request
-     (cider-stacktrace--stacktrace-request stacktrace)
+     `("op" "analyze-stacktrace"
+       "stacktrace" ,stacktrace
+       ,@(cider--nrepl-print-request-plist fill-column))
      (lambda (response)
        (setq causes (nrepl-dbind-response response (class status)
                       (cond (class (cons response causes))

cider-test.el

@@ -272,14 +272,11 @@ prompt and whether to use a new window.  Similar to `cider-find-var'."
   "Display stacktrace for the erring NS VAR test with the assertion INDEX."
   (let (causes)
     (cider-nrepl-send-request
-     (thread-last
-       (map-merge 'list
-                  `(("op" "test-stacktrace")
-                    ("ns" ,ns)
-                    ("var" ,var)
-                    ("index" ,index))
-                  (cider--nrepl-print-request-map fill-column))
-       (seq-mapcat #'identity))
+     `("op" "test-stacktrace"
+       "ns" ,ns
+       "var" ,var
+       "index" ,index
+       ,@(cider--nrepl-print-request-plist fill-column))
      (lambda (response)
        (nrepl-dbind-response response (class status)
          (cond (class  (setq causes (cons response causes)))

nrepl-dict.el

@@ -174,6 +174,16 @@ FUNCTION should be a function taking two arguments, key and value."
             (cons obj (car stack)))
           (cdr stack))))
 
+(defun nrepl--alist-to-plist (maybe-alist)
+  "Transform MAYBE-ALIST into a plist if it is an alist.
+Compatibility function for functions that used to accepts nrepl request
+options as alists.  A warning will be printed if alist is received."
+  (let ((first-arg (car-safe maybe-alist)))
+    (if (or (null first-arg) (not (listp first-arg)))
+        maybe-alist ;; It is a plist - don't have to convert
+      (warn "Received alist where it should have been plist: %s" maybe-alist)
+      (seq-mapcat #'identity maybe-alist))))
+
 (defun nrepl--merge (dict1 dict2 &optional no-join)
   "Join nREPL dicts DICT1 and DICT2 in a meaningful way.
 String values for non \"id\" and \"session\" keys are concatenated. Lists