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.