Looking for format string which allows custom formatting for list of pairs

Question

So I have lists, looking like this:

((24 . 23) (9 . 6) ... )

and want to custom format the output to something looking like this:

"24/23 9/6 ..."

I tried:

(defun show-pair (ostream pair col-used atsign-used) 
  (declare (ignore col-used atsign-used)) 
  (format ostream "~d/~d" (first pair) (second pair)))

(let ((x '( 1 . 2))) (format nil "~{~/show-pair/~^~}" (list x)))

as a simple warming up exercise to show a list with only 1 pair. But when trying this in the emacs slime repl, I get the error

The value 2 is not of type LIST [Condition of type TYPE-ERROR]

Which, of course is confusing as ~/show-pair/ was expected to handle one entry in the list, which is is the pair, passing the pair to show-pair. But it appears, something else is actually happening.

Gwang-Jin Kim · Answer 1 · 2021-01-26T22:04:23.857

If you want to do it with format - the problem is to access first and second element of the alist using format directives. I didn't found how I could access them inside a format directive.

However, in such regularly formed structures like an alist, one could flatten the list first and then let format-looping directive consume two elements per looping - then one consumes the pair.

Since the famous :alexandria library doesn't count as dependency in Common Lisp world, one could directly use alexandria:flatten:

(defparameter *al* '((24 . 23) (9 . 6)))
(ql:quickload :alexandria) ;; import alexandria library

(format nil "~{~a/~a~^ ~}" (alexandria:flatten *al*))
;; => "24/23 9/6"

nil return as string
~{ ~} loop over the list
~a/~a the fraction
~^ empty space between the elements but not after last element

flatten by the way without :alexandria-"dependency" would be in this case:

(defun flatten (l)
  (cond ((null l) nil)
        ((atom l) (list l))
        (t (append (flatten (car l)) (flatten (cdr l))))))

Yes, this is an idea I also considered, but my real data has sometimes more than 2 elements and sometimes numbers and sometimes symbols in some places. So, I pursued the `~/.../` approach as the function called is a bit more involved. — BitTickler, Jan 27 '21 at 07:56

score 1 · Answer 2 · answered Jan 25 '21 at 08:25

1

While waiting for feedback, I found out, where the problem is coming from:

So far, I considered (second x) to behave exactly like (cdr x) but for tagged values, this assumption is wrong. If I change in show-pairs above (in the question) accordingly, it all works.

So, it is not a formatting problem at all, nor any surprises with how ~/foo~/ works.

(defun show-pair (ostream pair col-used atsign-used) 
  (declare (ignore col-used atsign-used)) 
  (format ostream "~d/~d" (first pair) (cdr pair))) ;; second -> cdr fixes the problem

answered Jan 25 '21 at 08:25

BitTickler

10,905
5
32
53

`second` never behaves like `cdr`; [it behaves like `cadr`](http://www.lispworks.com/documentation/HyperSpec/Body/f_firstc.htm) – ad absurdum Jan 25 '21 at 08:47
The `cdr` synonym is `rest`. – Ehvince Jan 25 '21 at 11:02
Silly mistakes like this happen, whenever one uses other, new thing and focuses on those (like me using this way of formatting for the first time). – BitTickler Jan 25 '21 at 11:40

score 1 · Answer 3 · answered Jan 25 '21 at 12:56

It is fairly seldom a good idea to use ~/.../ in format in my experience. It's probably much better to simply turn the list you have into the list you need and then process that directly. So, for instance:

> (format t "~&~:{~D/~D~:^, ~}~%"
        (mapcar (lambda (p)
                  (list (car p) (cdr p)))
                '((1 . 2) (3 . 4))))
1/2, 3/4
nil

Or if you want to use loop:

 > (format t "~&~:{~D/~D~:^, ~}.~%"
        (loop for (n . d) in '((1 . 2) (3 . 4))
              collect (list n d)))
1/2, 3/4.
nil

The cost (and storage) associated with converting the list is likely to be absolutely tiny compared with the I/O cost of printing it.

chrnybo · Answer 4 · 2021-01-25T19:58:13.977

Using hints from Redefinition of the print-object method for conses..., you could end up with something like this:

CL-USER> (let ((std-function (pprint-dispatch 'cons)))
           (unwind-protect 
                (progn (set-pprint-dispatch 
                        'cons 
                        (lambda (s o) (format s "~d/~d" (car o) (cdr o))))
                       (format t "~{~a~%~}" '((23 . 24) (5 . 9))))
             (set-pprint-dispatch 'cons std-function))
           (format t "~{~a~%~}" '((23 . 24) (5 . 9))))
23/24
5/9
(23 . 24)
(5 . 9)
NIL
CL-USER>

Hiding the bookkeeping;

(defmacro with-fractional-conses (&body body)
  (let ((std-function (gensym "std-function")))
    `(let ((,std-function (pprint-dispatch 'cons)))
       (unwind-protect 
            (progn (set-pprint-dispatch 
                    'cons 
                    (lambda (s o) (format s "~d/~d" 
                                          (car o) 
                                          (cdr o))))
                   ,@body)
         (set-pprint-dispatch 'cons ,std-function)))))


CL-USER> (with-fractional-conses 
           (format t "~{~a~%~}" 
                   '((23 . 24) (5 . 9))))
23/24
5/9
NIL
CL-USER>

This (v1) is a fairly dangerous approach because it's essentially shallow-binding the dispatch table (really: it's shallow-binding entries in the table), and shallow-binding is very hard to make thread-safe and certainly would not be in this case. A better approach is to make a copy of the table and then explicitly bind `*print-pprint-dispatch*` to that copy. This is a clever trick however! — , Jan 26 '21 at 18:08

Looking for format string which allows custom formatting for list of pairs

4 Answers4