How do I format a list of strings

Question

I have a list of strings that I need to format using emacs lisp. This was the only way I could think of going about it:

(setq slist '("is there" "any" "way" "directed iteration"))    
(format "%s _%s_ %s to do %S in elisp?" 
        (elt slist 0)
        (elt slist 1)
        (elt slist 2)
        (elt slist 3)
        (elt slist 4))

Giving me what I want.

is there _any_ way to do "directed iteration" in elisp?

There must be a more elegant way, but after much thought, I'm not seeing it. I'm very new to emacs lisp and I might be missing something obvious.

Answer 1

I've decided to make it into a standalone project by adding some more features, fixing some bugs and adding more bugs! yey :)

You can find the project here: http://code.google.com/p/formatting-el/source/browse/trunk/formatting.el

Not sure how much buggy this is, but at the first sight it seems to work:

(defun directive-end (c)
  (member c "csdoxXeg%"))

(defun pp-if-nil (spec)
  (position ?\% spec))

(defun pp-list (spec args)
  (let ((pos 0) (last 0) (fstring "% ") current seen-^)
    (catch 't
      (while t
        (setq pos (1+ (or (position ?% spec :start pos) -1))
              current (aref spec pos))
        (unless (and seen-^ (char-equal current ?\}) (null args))
          (princ (substring spec last (1- pos))))
        (setq last pos pos (1+ pos))
        (cond
         ((char-equal current ?^)
          (incf last)
          (setq seen-^ t))
         ((char-equal current ?\{)
          (setq pos (+ pos (pp-list (substring spec pos) (car args)))
                args (cdr args)
                last pos
                seen-^ nil ))
         ((char-equal current ?\})
          (if args (setq pos 0 last 0)
            (throw 't nil)))
         ((char-equal current ?%)
          (setq seen-^ nil last (1+ last))
          (write-char ?%))
         (t (unless args (error "Not enough argumens for list iteration"))
            (setf (aref fstring 1) current)
            (princ (format fstring (car args)))
            (setq args (cdr args)
                  seen-^ nil
                  last 
                  (or (position-if #'directive-end spec :start pos)
                      pos)))))) pos))

(defun cl-format (spec &rest args)
  (with-output-to-string
    (let ((pos 0) (last 0) (fstring "% ") current)
      (catch 't
        (while t
          (setq pos (1+ (or (position ?\% spec :start pos) -1))
                current (aref spec pos))
          (when (= pos 0) (throw 't nil))
          (princ (substring spec last (1- pos)))
          (setq last pos pos (1+ pos))
          (cond
           ((char-equal current ?^)
            (unless args
              (setq last (pp-if-nil spec)
                    pos last)))
           ((char-equal current ?\{)
            (setq pos (+ pos (pp-list (substring spec pos) (car args)))
                  args (cdr args)
                  last pos))
           ((char-equal current ?\})
            (error "Unmatched list iteration termination directive"))
           ((char-equal current ?%)
            (write-char ?%)
            (incf last))
           (t (unless args (error "Not enough argumens"))
              (setf (aref fstring 1) current)
              (princ (format fstring (car args)))
              (setq args (cdr args)
                    last 
                    (or (position-if #'directive-end spec :start pos)
                        pos))))
          (incf pos))))))

(cl-format "begin: %{%s = %d%^,%}; %% %c %% %{%{%s -> %d%^.%},%}"
           '(a 1 b 2 c 3) ?\X '((a 2 b 4 c 6) (a 1 b 3 c 5)))
"begin: a = 1,b = 2,c = 3; % X % a -> 2.b -> 4.c -> 6,a -> 1.b -> 3.c -> 5,"

This tries to replicate some (very simplistic) Common Lisp-like printing behaviour of the ~{ ... ~} directives.

Answer 2

Use apply:

(apply 'format "%s _%s_ %s to do %S in elisp?" slist)

The apply function takes a function (or symbol) as its first argument, then a number of individual arguments, finishing with a list of arguments.