Can I return information about a transient from a suffix invocation?

[Hugo-Heagren]

Transient is a very powerful and comfortable interface for choosing things. I want to use transient to select one or several elements of a list in a package I'm building. For minimal example, lets say the objects are selectable objects, which each have a name and key slot. I need a function which:

• takes a list of selectable objects as argument (e.g. selectable-list)
  • displays the list in a transient popup, where the key of each entry is the value of the key slot in each selectable, and the description of each entry is the value of the name slot.
  • hitting a key selects the relevant object, but keeps the transient open (so several objects can be selected at once)
  • the transient should have a 'confirm selection' key of some kind
• once the confirm key is hit, return a list of all the selectables which were selected

I can't make the last bullet point happen. Is this something transient can or should do? If so, how can I do it? Here's what I have so far:

(require 'eieio)
(require 'transient)

(defclass selectable ()
  ((key :initarg :key)
   (name :initarg :name)))

;; * Toy objects

(setq foo (make-instance 'selectable :key "f" :name "foo"))
(setq bar (make-instance 'selectable :key "b" :name "bar"))
(setq baz (make-instance 'selectable :key "z" :name "baz"))
(setq selectable-list `(,foo ,bar ,baz))

;; * Internal code

;; We store whether the thing is selected in the `value' slot. Store
;; the selectable object we are selecting in the
;; `selectable' slot.
(defclass transient-selectable (transient-infix)
  (;; Lack of an initform is deliberate---there should never be an
   ;; object without a specific value for `selectable,' so a
   ;; default value would be pointless.
   (selectable :initarg :selectable :type selectable)
   (format :initform " %k %d")
   ;; Default to unselected
   (value :initform nil))
  "Class for infix commands that represent a transient selectable.")

(cl-defgeneric selectable-to-transient (prefix selectable)
  "Return a transient suffix spec for selecting SELECTABLE in PREFIX.")

(cl-defmethod selectable-to-transient (prefix (selectable selectable))
  "Return a transient suffix spec for selecting SELECTABLE in PREFIX."
  (let* (;; (name (slot-value selectable 'name))
	 (key (slot-value selectable 'key))
	 (description (slot-value selectable 'name))
	 (command (lambda ()
		    (interactive)
		    ;; Standard infix definition
		    (let ((obj (transient-suffix-object)))
		      (transient-infix-set obj (transient-infix-read obj)))
		    (transient--show)))
	 (spec `(,key ,description ,command :class transient-selectable))
	 (parsed (transient-parse-suffix prefix spec)))
    ;; Mutate the property list
    (plist-put (caddr parsed) :selectable selectable)
    ;; Return the whole object, with the mutated list
    parsed))

;; * Methods we need

;; Cribbed from transient-switch
(cl-defmethod transient-infix-read ((obj transient-selectable))
  "Toggle the selectable selected or not."
  (if (slot-value obj 'value) nil t) )

(defface transient-selected '((nil . (:inherit transient-value)))
  "Face for selected searchables in `choose-selectable'.")

(cl-defmethod transient-format-description ((obj transient-selectable))
  (when-let ((desc (slot-value obj 'description)))
    (if (functionp desc)
        (with-current-buffer transient--original-buffer
          (funcall desc))
      (if (slot-value obj 'value)
	  (propertize desc 'face 'transient-selected)
	desc))))

;; We need this because the standard method (which
;; `transient-selectable' would fall back to) tries to access the
;; `argument' slot, but the argument slot is unitialised here.
(cl-defmethod transient-format-value ((obj transient-selectable))
  (format "%s" (slot-value obj 'value)))

;; * Transient selector

(transient-define-prefix transient-choose-selectable (selectables)
  [["Searchables" ;; TODO Name?
    :class transient-column
    :setup-children
    (lambda (_)
      (mapcar (apply-partially
	       'selectable-to-transient
	       'transient-choose-selectable
	       ;; transient--prefix
	       )
	      selectables))]
   [("RET" "Search!"
     (lambda ()
       (interactive)
       ;; This is the naive attempt to return the selected objects,
       ;; but it doesn't work.
       (mapcar
	(lambda (obj)
	  (slot-value obj 'selectable))
	(seq-filter
	 (lambda (obj)
	   ;; Filter for selectables...
	   (and (transient-selectable-p obj)
		;; ... but only those which are selected!
		(slot-value obj 'value)))
	 ;; current-transient-suffixes
	 (transient-args 'transient-choose-selectable)
	 ))))]]
  ;; The interactive spec is here because Transient requires it. But
  ;; in practice this function should never be called without passing
  ;; arguments, so we raise an error if that happens.
  (interactive (error "No SELECTABLES arg specified"))
  (transient-setup 'transient-choose-selectable))

If I run (setq var (transient-choose-selectable selectable-list)), select something and press RET, then inspect var, the value of var is still nil. I see why this is happening: the body of transient-choose-selectable finishes with transient setup and then exits (returning nil). Is there any way I can retain or access the return value of the final confirmation?

[tarsius]

I plan to implement support for "returning values", but I don't think I will get to it for a few more months. Sorry.

[Hugo-Heagren]

Excellent news, thanks! Are you aware of a workaround in the meantime? I tried a few hacks with variables and non-local exits but couldn't get something that worked.

[tarsius]

Try combining the approach of using a global "return value variable" with recursive-edit.

[aurtzy]

Hey! I've been looking into something like what you describe, and would like to share my findings in case others are interested.

(Some more comments on code are also included in the snippets. Possibly has some bugs.)

With a few hacks, I managed to get a recursive-edit approach working:

Code

(require 'transient)

(defvar demo-variable 0)

(defun demo-exit-recursive-edit ()
  (remove-hook 'transient-exit-hook #'demo-exit-recursive-edit)
  (exit-recursive-edit))

(transient-define-prefix demo-subdispatch ()
  ["Test"
   ("1" "Return 1" (lambda () (interactive) (setq demo-variable 1)))
   ("2" "Return 2" (lambda () (interactive) (setq demo-variable 2)))]
  (interactive)
  (transient-setup 'demo-subdispatch)
  ;; This advice causes the menu to be hidden when entering `recursive-edit', so
  ;; remove it.
  (advice-remove 'recursive-edit #'transient--recursive-edit)
  ;; "Return" after submenu closes.
  (add-hook 'transient-exit-hook #'demo-exit-recursive-edit)
  ;; The menu doesn't seem to get a chance to actually display before
  ;; `recursive-edit' is called, so nothing gets shown if we don't explicitly
  ;; call `redisplay'.
  (redisplay)
  (recursive-edit))

(transient-define-prefix demo-dispatch ()
  ["Test"
   ("v" demo-subdispatch
    :description
    (lambda ()
      (concat "Set variable (" (prin1-to-string demo-variable) ")"))
    :transient t)]
  (interactive)
  ;; Reset variable for `demo-dispatch' invocation.
  (setq demo-variable 0)
  (transient-setup 'demo-dispatch))

My experimenting also led to another approach, (ab)using Transient's scope feature to pass a shared object between prefixes (i.e., modifying scope value changes it for all sub/parent-prefixes with the object). For demonstration purposes, I used a list as a means of passing around a reference; my package uses a class object for scope values to make this more manageable, which should also be fairly easy to extend to satisfy this use case.

Code

(require 'transient)

(defclass demo-prefix (transient-prefix) ()
  "Class for managing shared scope between `demo-prefix' prefixes.")

(cl-defmethod transient-init-scope ((obj demo-prefix))
  ;; Adapted from `disproject.el'.  Scopes between `demo-prefix' classes are
  ;; shared by reference, so modifying the scope in a subprefix causes it to be
  ;; modified in the parent prefix as well.
  (if (cl-typep transient-current-prefix 'demo-prefix)
      (let ((scope (transient-scope)))
        (oset obj scope scope))
    ;; This method is also called for situations like returning from a
    ;; sub-prefix, in which case we want to keep the existing scope.
    (unless (oref obj scope)
      (oset obj scope (list 0)))))

(transient-define-prefix demo-subdispatch ()
  :class demo-prefix
  ["Test"
   ("1" "Return 1" (lambda () (interactive)
                     (setf (car (transient-scope)) 1)))
   ("2" "Return 2" (lambda () (interactive)
                     (setf (car (transient-scope)) 2)))])

(transient-define-prefix demo-dispatch ()
  :class demo-prefix
  ["Test"
   ("v" demo-subdispatch
    :description
    (lambda ()
      (concat "Set variable (" (prin1-to-string (car (transient-scope))) ")"))
    :transient t)])