Question

I’d like to be able to define lambdas using common Lisp syntax, in Clojure. For example:

(lambda (myarg)
  (some-functions-that-refer-to myarg))

This needs to result in the same as:

#(some-functions-that-refer-to %)

In my case, I know I’ll always have exactly one arg, so perhaps that simplifies things. (But it can be called anything — “myarg” or whatever.)

I suspect a workable solution is to “(defmacro lambda …”. If so, I’m not sure of the best way to proceed. How to cleanly translate the arg name to %? And how to end up with the correct function?

Or, is there a simpler solution than writing my own macro that actually re-implements Clojure’s… lambda?

Answer 1

#(foo %) is just reader shorthand for (fn [arg] (foo arg)). There’s no reason to write a macro that expands into #(...). All the %‘s in a #(...) construct are expanded into gensyms right away anyways.

user> `#(foo % %1 %2)
(fn* [user/p1__1877 user/p2__1878] 
  (user/foo user/p1__1877 user/p1__1877 user/p2__1878))

If you’re ever writing a macro that expands to build anonymous functions, you might as well just expand them to fn forms yourself. In your case, you should probably just use fn directly and skip the macros. fn is Clojure’s lambda.

The difference between (fn [] ...) and (lambda () ...) in this case is that “fn” is shorter to type than “lambda”, and fn takes a vector for its bindings whereas lambda takes a list. If you’re using Clojure, you will have to get used to this eventually, because vectors are always used for collections of bindings, in all the do forms and in for and binding etc. The rationale behind this as I understand it is that lists are used for function calls or macro calls, and vectors are used for things that aren’t calls (lists of symbols to bind, for example). Arguably, it makes it easier to scan the code visually than lists-all-the-way-down. Clojure is not Common Lisp, and you will experience pain if you try to force it to be.

If you really, really wanted to do this, just to say you did:

user> (defmacro lambda [args & body]
        `(fn ~(vec args) ~@body))
user> ((lambda (x) (println x)) "foo")
foo
nil

This doesn’t let you put a docstring or metadata on your function, among other things. I don’t think you would want to use this in a real Clojure program.