How to change Org-mode Babel lisp source code block from SLIME to SLY?

Question

I found ob-lisp.el use SLIME by default to evaluate lisp code. I want to use SLY to evaluate lisp code. How to change it? I found the file ob-lisp.el is short. I tried to change slime to sly. But it is not customizable. I hope to define a defcustom for it. So that user can customize it. But I don't know how to apply this into code. For example, I define a custom like this:

(defcustom org-babel-lisp-default-implement "slime")

((defcustom org-babel-lisp-implements
   '("slime" "sly")
   "A list of Lisp implements."
   :group 'org-babel
   :version "24.1"
   ;; FIXME: reference code example.
   :type listp))

Then in file ob-lisp.el. Has some places use slime. I want to make them adapt to upper defcustom value. like concate string from value or something else.

(declare-function slime-eval "ext:slime" (sexp &optional package))

(defun org-babel-execute:lisp (body params)
  "Execute a block of Common Lisp code with Babel."
  (require 'slime)
  (org-babel-reassemble-table
   (let ((result
          (funcall (if (member "output" (cdr (assoc :result-params params)))
                       #'car #'cadr)
                   (with-temp-buffer
                     (insert (org-babel-expand-body:lisp body params))
                     (slime-eval `(swank:eval-and-grab-output
....

Answer 1

The easiest way is to parametrize the call slime-eval, using funcall and a defvar/defcustom and take advantage use of sly's retro contrib, which allows the user to refer to the slynk pacage by the name of swank. Besides the replacing (slime-eval ...) with (funcall org-babel-lisp-eval-fn ...) the other thing we must do is to require slime or sly when appropiate. I'm using pcase but there may be a more appropriate string-case in emacs lisp.

(defcustom org-babel-lisp-eval-fn
  '("slime-eval" "sly-eval")
   "The function to be called to evaluate code on the lisp side."
   :group 'org-babel
   :version "24.1"
   :type listp)

(defun org-babel-execute:lisp (body params)
  "Execute a block of Common Lisp code with Babel."
  (pcase org-babel-lisp-eval-fn
    ("slime-eval" (require 'slime))
    ("sly-eval" (require 'sly)))
  (org-babel-reassemble-table
   (let ((result
      (funcall (if (member "output" (cdr (assoc :result-params params)))
               #'car #'cadr)
           (with-temp-buffer
             (insert (org-babel-expand-body:lisp body params))
             (funcall org-babel-lisp-eval-fn
                              `(swank:eval-and-grab-output
                                ,(let ((dir (if (assoc :dir params)
                                                (cdr (assoc :dir params))
                                              default-directory)))
                                   (format
                                    (if dir (format org-babel-lisp-dir-fmt dir)
                                      "(progn %s\n)")
                                    (buffer-substring-no-properties
                                     (point-min) (point-max)))))
                              (cdr (assoc :package params)))))))
     (org-babel-result-cond (cdr (assoc :result-params params))
       result
       (condition-case nil
           (read (org-babel-lisp-vector-to-list result))
         (error result))))
   (org-babel-pick-name (cdr (assoc :colname-names params))
            (cdr (assoc :colnames params)))
   (org-babel-pick-name (cdr (assoc :rowname-names params))
            (cdr (assoc :rownames params)))))

Answer 2

Please note that if you have a modern enough version of org mode you can just simply do

  (setq org-babel-lisp-eval-fn #'sly-eval)