(defmacro with-default (starting-val &rest body)
`(let ((_ ,starting-val))
,@(mapcar #'(lambda (line)
`(setf _ ,line))
body)))

(with-default "this is a new foo"
(regex-replace-all "this" _ "that")
(regex-replace-all "old" _ "new")
(regex-replace-all "foo" _ "bar"))


That’s an idea I’ve toyed with too, but I’m not sure how well it would work with macros. For example, if a macro wanted to add extra arguments to a function call, it would have to insert them before the last item in the list. Certainly doable, but less convenient than just sticking them on the end.

And reversing the order of the S-exps wouldn’t help the readability of deeply-nested expressions. Indeed, it might make them harder to read. No, it’s an interesting solution, but not the one I’m looking for.

“I like to think it would be possible to combine the flexibility of Lisp’s S-expressions with the left-to-write readability of object.method, but I don’t know what that would be.”

Would putting the function in the last position of the S-exp instead of the first position do what you want? As in:

(((string “this” “that” regex-replace-all) “old” “new” regex-replace-all) “foo” “bar” regex-replace-all)

I thought about doing that, but never got around to it. Maybe I’m just lazy.

(gsub string '(("this" "that") ("old" "new") ("foo" "bar")))

This even manages to be a couple of characters shorter than the Ruby version, which is saying something.

Shorthand like this should arguably already be provided by CL-PPCRE, but if it’s missing, it’s trivial enough to add - which is the whole point of Lisp, anyway. Any new abstraction you can imagine, you can build.