How to evaluate a list containing strings or un-evaluated blocks into a string? (like format-mode-line)

Question

The mode-line-format can be a list of strings, but it can also include un-evaluated blocks, e.g:

(setq mode-line-format
  (list
    "Hello"
    '(:eval (my-function-call))
    "There"))

I would like to store a list in a similar format which can be converted into a string.

However I don't want to use format-mode-line as I don't want %p etc.. to have special meanings.

Is there a utility function for doing this? Or would I need to implement the logic to extract/evaluate a string from the list myself?

Answer 1

If you really just want a list (and not a tree like format-mode-line) that can be evaluated takes element-wise to strings and then concatenated mapconcat and eval are your friends:

(let ((my-list '("Hello, I am " (number-to-string (user-uid)) " and it is " (format-time-string " %T, %F"))))
  (mapconcat #'eval my-list ""))

The output is:

Hello, I am 1000 and it is  11:47:45, 2021-02-03

A more general version can also be implemented quite simple in a recursive way:

(defun tree-to-string (tree &optional lexical)
  "Convert TREE recursively to a string.
TREE can be one of the following:
- lists with car :eval : the cdr is evaluated and the result is passed to `tree-to-string'
- other lists: element-wise processed with `tree-to-string'
- any other element: transformed to string with `prin1-to-string'
The optional argument LEXICAL is passed to `eval'."
  (if (listp tree)
      (if (eq (car tree) :eval)
      (tree-to-string (eval (cons 'progn (cdr tree)) lexical))
    (mapconcat (lambda (item) (tree-to-string item lexical)) tree ""))
    (prin1-to-string tree t)))

(tree-to-string '("Hello, I am " (:eval (user-uid)) (" and it is " (:eval (format-time-string "%T, %F"))) "."))

The output is:

Hello, I am 1000 and it is 11:47:45, 2021-02-03.

Answer 2

Adding an answer based on @Tobias's answer with changes.

• Support :propertize (as mode-line-format does).
• Support symbols (which are resolved into strings).
• Call eval with lexical binding set to t.
• Raise an error for unsupported values (instead of converting them into strings), this means mistakes are more easily caught.

(defun tree-to-string (tree)
  "Convert TREE recursively to a string.
TREE can be one of the following:
- lists with `car' `:eval'
  - the `cdr' is evaluated and the result is passed to `tree-to-string'
- lists with `car' `:propertize'
  - the `caar' is passed to `tree-to-string'.
  - the `cddr' is passed to as properties to `propertize'.
- other lists: element-wise processed with `tree-to-string'
- a symbol, it's value is transformed to string with `prin1-to-string'.
- any other element must be a string.
"
  (cond
    ((stringp tree)
      tree)
    ((null tree)
      "")
    ((symbolp tree)
      ;; Support non-string symbols, allows numbers etc to be included.
      (prin1-to-string (symbol-value tree) t))
    ((listp tree)
      (let ((tree-type (car tree)))
        (cond
          ((eq tree-type :eval)
            (tree-to-string (eval (cons 'progn (cdr tree)) t)))
          ((eq tree-type :propertize)
            (pcase-let ((`(,item . ,rest) (cdr tree)))
              (apply 'propertize (cons (tree-to-string item) rest))))
          (t
            (mapconcat #'tree-to-string tree "")))))
    (t
      (error
        "Found '%S' (%S), not a string, nil or `:eval' cons or list of these"
        (type-of tree)
        tree))))

Example usage:

;; Define a value that can be evaluated into a string at any time.
(defvar my-custom-format
  (list
    "Hello, User files are in "
    'user-emacs-directory
    " and it is "
    '(:eval (format-time-string "%T, %F "))
    '(:propertize "This text is green" face (:background "green"))
    "."))

;; Evaluate and show the string.
(message "%s" (tree-to-string my-custom-format))