Alternatives (v0.2.20141117) ReleasedNovember 17th, 2014 Patrick Stein

I have uploaded a new version of my Alternatives library. In addition to the `ALTERNATIVES` macro, there is an `ALTERNATIVES*` macro which allows one to specify a name for the set of choices. Then, one can check the `DOCUMENTATION` to see which alternative was last macroexpanded.

(defun random-letter ()
(alt:alternatives* random-letter-algorithm
***
(:constant-a
"Always pick the letter A."
#\A)

(:uniform
"Choose any letter with equal probability"
(random:random-elt "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))))

(documentation 'random-letter-algorithm 'alt:alternatives)
=> "CONSTANT-A
Always pick the letter A."

Alternatives (v0.1.20141115) ReleasedNovember 16th, 2014 Patrick Stein

I have now released the code that I mentioned in my previous post Code That Tells You Why which lets one keep multiple implementations around in code and switch between them manually without much trouble.

A link to the source code is here: nklein.com/software/alternatives/.

Code That Tells You WhyNovember 13th, 2014 Patrick Stein

A 2006 article by Jeff Atwood titled Code Tells You How, Comments Tell You Why showed up on reddit/r/programming today.

It makes a good point. However, it got me thinking that for cases like the binary-search example in the article, it might be nice to see all of the alternatives in the code and easily be able to switch between them.

One way to accomplish this in Lisp is to abuse the `#+` and `#-` reader macros:

(defun sum-i^2 (n)
#+i-wanted-to-do-this
(loop :for i :to n :summing (* i i))

#+my-first-attempt-was-something-like-this
(do ((i 0 (1+ i))
(sum 0 (+ sum (* i i))))
((> i n) sum))

#+but-i-could-not-do-that-because
"Some people find a do-loop to hard to read
(and 'too' too hard to spell, apparently)."

#-now-i-know-better-and-can-do-this
(/ (* n (1+ n) (1+ (+ n n)) 6))

This is less than ideal for a number of reasons, including: one needs to make sure to pick “feature” names that won’t actually ever get turned on, the sense of `+` and `-` seem backwards here, and switching to a different alternative requires editing two places.

Another Lisp alternative is to abuse the `case` form:

(defun sum-i^2 (n)
(case :now-i-know-better-and-can-do-this
(:i-wanted-to-do-this
(loop :for i :to n :summing (* i i)))

(:my-first-attempt-was-something-like-this
(do ((i 0 (1+ i))
(sum 0 (+ sum (* i i))))
((> i n) sum)))

(:but-i-could-not-do-that-because
"Some people find a do-loop to hard to read
(and 'too' too hard to spell, apparently)."
)

(:now-i-know-better-and-can-do-this
(/ (* n (1+ n) (1+ (+ n n)) 6)))))

This is better. No one can doubt which alternative is in use. It is only one edit to switch which alternative is used. It still feels pretty hackish to me though.

One can clean it up a bit with some macrology.

(defmacro alternatives (&body clauses)
(flet ((symbol-is-***-p (sym)
(and (symbolp sym)
(string= (symbol-name sym) "***")))
(final-clause-p (clause)
(when (listp clause)
(destructuring-bind (tag &body body) clause
(when (and (symbolp tag)
(member (symbol-name tag)
'("***" "FINAL" "BLESSED")
:test #'string=))
body)))))
(anaphora:acond
((member-if #'symbol-is-***-p clauses)
(let ((clause (first (rest anaphora:it))))
`(progn
,@(rest clause))))

((find-if #'final-clause-p clauses)
`(progn
,@(rest anaphora:it)))

((last clauses)
`(prog
,@(rest (first anaphora:it)))))))

With this macro, one can now rewrite the `sum-i^2` function quite readably:

(defun sum-i^2 (n)
(alternatives
(i-wanted-to-do-this
(loop :for i :to n :summing (* i i)))

(my-first-attempt-was-something-like-this
(do ((i 0 (1+ i))
(sum 0 (+ sum (* i i))))
((> i n) sum)))

(but-i-could-not-do-that-because
"Some people find a do-loop to hard to read
(and 'too' too hard to spell, apparently)."
)

(now-i-know-better-and-can-do-this
(/ (* n (1+ n) (1+ (+ n n)) 6)))))

If I wanted to try the `my-first-attempt-was-something-like-this` clause, I could stick a `***` before that clause or change its name to `***` or `final` or `blessed`, or I could move that clause into the last spot.

There is still an onus on the developer to chose useful alternative names. In most production code, one wants to clean out all of the dead code. On the other hand, during development or for more interactive code bodies, one might prefer to be able to see the exact “How” that goes with the “Why” and easily be able to swap between them.

(Above macro coming in well-documented library form, hopefully this weekend.)