Ryan's Tech Blog

We’re grinding (in the RPG sense) with lisp at work, and keep coming into problems that have multiple simple solutions, but don’t have the instincts/knowledge to readily identify which one is best. One such problem is building up strings, in a couple of cases. I took some time this morning to go through the cases, using a 10000 iteration loop and time to do a simple benchmark. The tests were run on SBCL 1.0.11.

UPDATE: added metrics with *PRINT-PRETTY* off, as suggested in comments. This has a big effect.

Conversion

There are some cases where we wanted a number as a string, as part of building HTML. For this demo, we’ll put the number in variable *d*:

(defvar *d* 19.80)

We found three options:

1. cl-interpol: #?”${*d*}” => “19.8”
2. (princ-to-string *d*) => “19.8”
3. (format nil “~a” *d*) => “19.8”

Here’s how they compared:

Princ-to-string is the bigger winner in this case.

Simple Prepending

For the this case, we have some decimal value in a variable called *d*, and want it in a string, prepended with a “$”.

We identified three possible solutions:

1. (arnesi:join-strings (list “$” (princ-to-string *d*))) => “$19.8”
2. cl-interpol: #?”$${*d*}” => “$19.8”
3. (format nil “$~a” *d*) => “$19.8”

Here’s how they compared:

In this case, cl-interpol wins on all counts, after compile time.

Dynamic Prepending

In this case, our prefix is determined by another variable:

(defvar *prefix* "$")

1. (arnesi:join-strings (list *prefix* (princ-to-string *d*))) => “$19.8”
2. cl-interpol: #?”${*prefix*}${*d*}” => “$19.8”
3. (format nil “~a~a” *prefix* *d*) => “$19.8”

Now things get a little messier, and dependent on the setting of *PRINT-PRETTY*. join-strings wins big if *PRINT-PRETTY is on, but if its off, then cl-interpol takes the cake again.

Simple Wrapping

In this case we want to put some text before and after our value.

The options:

1. (arnesi:join-strings (list “$” (princ-to-string *d*) ” USD”)) => “$19.8 USD”
2. cl-interpol: #?”$${*d*} USD” => “$19.8 USD”
3. (format nil “$~a USD” *d*) => “$19.8 USD”

The data:

cl-interpol is still the winner, which is expected given the results of the simple prepending.

Dynamic Wrapping

Now let’s put the suffix into a variable and see how it goes:

(defvar *suffix* "USD")

The options:

1. (arnesi:join-strings (list *prefix* (princ-to-string *d*) ” ” *suffix*)) => “$19.8 USD”
2. cl-interpol: #?”${*prefix*}${*d*} ${*suffix*}” => “$19.8 USD”
3. (format nil “~a~a ~a” *prefix* *d* *suffix*)=> “$19.8 USD”

The results:

Another mixed result, depending on *PRINT-PRETTY*. Again we have join-strings if you need *PRINT-PRETTY*, cl-interpol if not.

My Conclusions

Use princ-to-string for simple conversions, use cl-interpol everywhere if you can turn off *PRINT-PRETTY*. If I need *PRINT-PRETTY*, then use cl-interpol and replace it with join-strings when tuning performance.