alt.hn

5/18/2026 at 7:27:25 PM

Hyperpolyglot Lisp: Common Lisp, Racket, Clojure, Emacs Lisp

 https://hyperpolyglot.org/lisp

by veqq

5/18/2026 at 9:56:16 PM

Notes on CL:

- why nothing on the "compiler" line? Everytime you load a snippet or a file with SBCL, it compiles it (to machine code). There's also compile-file.

- interpreter: likewise, all code is compiled by default with SBCL, not interpreted, even in the REPL. To use the interpreter, we must do this: https://github.com/lisp-tips/lisp-tips/issues/52

- command line program: the racket cell shows the use of -e (eval), the same can be done with any CL implementation.

- since the string split line introduces cl-ppcre, one could mention cl-str :D (plug) (much terser join, trim, concat etc)

- ah ok, for dates and times, flattening a list, hash-table literals… we need more libraries.

- more files operations: https://lispcookbook.github.io/cl-cookbook/files.html

- emacs buffers: now compare with Lem buffers 8-)

- posix-getenv: I'd rather use uiop:getenv (comes in implementations).

- uiop:*command-line-arguments*

- exit: uiop:quit

- uiop:run-program (sync) / launch-program (async)

- java interop: with LispWorks or ABCL (or other libraries)

my 2c

by vindarel

5/18/2026 at 10:17:43 PM

Since you are also commenting libraries, I think that FSet (1) for inmutable memory,and perhaps a comparison with clojure, and the quick-lisp package manager could be mentioned.

(1) https://news.ycombinator.com/item?id=47779659

by sinsudo

5/19/2026 at 4:32:21 AM

> - ah ok, for dates and times

local-time has its limits (e.g. Gregorian only), but it does everything listed in this chart

> flattening a list

What? Isn't this[1] just fine (<s>)

> hash-table literals…

Since the chart is sbcl specific, this ugly mess would technically count; a more portable (but longer) version could be made similarly using #.:

  #.(SB-IMPL::%STUFF-HASH-TABLE (MAKE-HASH-TABLE :TEST 'EQUAL) '((:X . :Y)))
> java interop: with LispWorks or ABCL (or other libraries)

I've had good luck with .net/java interop using FOIL (written by Rich Hickey prior to Clojure).

1:

  CL-USER> (let* ((result (cons nil nil))
                 (tail result))
             (subst-if t
                       (constantly nil)
                       '(a ((b(c d)) e) f)
                       :key (lambda (x)
                              (when (and x (atom x)) (setf (cdr tail) (cons x   nil)
                                                           tail (cdr tail)))))
             (cdr result))
=> (A B C D E F)

by aidenn0

5/19/2026 at 10:49:10 AM

Hash-table literals are covered by (among others):

  - Serapeum
  - golden-utils
  - rutils
  - make-hash
Though now I'm wondering which libraries would make for a proper canonical extended core... asdf, uiop (comes with asdf, so naturally), alexandria, bordeaux-threads, cffi, cl-ppcre, str, local-time, trivia,... and maybe fset? (although I personally prefer Sycamore's naming conventions)

...maybe also fivem (although I personally prefer parachute) and hunchentoot.

by tmtvl

5/18/2026 at 8:43:10 PM

I know that the purpose of the page is to compare syntax of common lisp, racket, clojure, and emacs lisp. But some examples could be more idiomatic, for instance instead of

  (defun add (a &rest b)
    (if (null b)
        a
        (+ a (eval (cons '+ b)))))
One should avoid eval and use endp instead of null:

   (defun add (a &rest b)
        (if (endp b) a
            (apply #'add (+ a (first b)) (rest b))))

by sinsudo

5/19/2026 at 4:44:27 AM

The use of cl:eval alone is enough to make me believe that the CL column was never reviewed by an experienced CL programmer. I am now more suspicious of the other columns, which are languages I'm far less familiar with.

by aidenn0

5/19/2026 at 12:25:57 PM

> I am now more suspicious of the other columns, which are languages I'm far less familiar with.

It's not bad but for Clojure for example it says "nil is like null in Java" but null in Java is not falsy.

And it also says that destructuring is "named parameters" but it's not so: it's just destructuring (and there are two examples of destructuring given: one for the "named parameters" which aren't named parameters, and one for "parallel assignment" of local variables).

Nothing bad but it's not possible to go into much details in such a table.

by TacticalCoder

5/19/2026 at 6:10:53 AM 

  (defparameter *a* '(1 2 3))
  (setf (car *a*) 3)
And this is undefined behavior because it mutates literal constant. I stopped reading further. The CL column is so bad.

by kscarlet

5/19/2026 at 11:11:23 AM

The trap is using quote, with the list operator there are no issues:

    (defparameter *a* (list 1 2 3))
and of course, mutating top-level variables is bad style.

by vindarel

5/18/2026 at 10:31:40 PM

Shouldn't it be (+ a (apply + b))

by CodeArtisan

5/18/2026 at 11:48:58 PM

Almost. It should be (+ a (apply #'+ b)). Common Lisp is a Lisp-2, so a + in the argument position is assumed to be a variable named +, not the function named +, unless you specify otherwise.

by db48x

5/19/2026 at 1:24:10 PM

No, the idea is to assume for this example that + only can be used with two arguments and define a new function that can be used with any number of arguments.

by gus_massa

5/18/2026 at 11:06:28 PM

Worse: Using recursion in Common Lisp isn't idiomatic, given that CL doesn't guarantee tail-call optimisation in the specification.

by ludston

5/19/2026 at 12:55:16 AM

Sigh. This again.

All major Common Lisps support tail call optimization with proper declarations, with the exception of ABCL because it runs on the JVM.

And those declarations are all identical or almost identical, so it's easy to write an implementation-specific macro to guarantee TCO if you need to do so.

Some algorithms are easiest to express and read with looping constructs. For those algorithms, use looping constructs. Other algorithms are easiest to express and read with recursion. For those, use recursion. You shouldn't be afraid of recursion just because ANSI doesn't say TCO is guaranteed. You should be afraid of it if your code needs to run on ABCL, but otherwise, recur on.

by dreamcompiler

5/19/2026 at 4:16:39 AM

I think it is fair to say that the CL community is divided on whether or not relying on TCO is idiomatic.

I prefer to write my state-machines as transitioning with tail-calls, and I do get called for it. It's relatively easy to switch something written in that manner to using a loop with a trampoline, so I do so when my collaborators request it.

by aidenn0

5/19/2026 at 4:35:06 AM

I wouldn't argue about things that are a matter of taste normally, except that I've had the experience where I've turned down optimizer settings in order to debug some code better and then the had stack overflow.

by ludston

5/19/2026 at 3:27:13 AM

Sigh and yet it continues to be true. You can make a pragmatic decision and rely on tail call optimisation for your specific case, but if you are writing a CL library, then it is not idiomatic to use recursion in the same way that you would for Clojure or Scheme.

Even with SBCL, for example, it doesn't have tail-call optimisation for all architectures at all optimisation levels.

by ludston

5/18/2026 at 9:47:19 PM

As someone who's not a programmer but has beginner - medium python & C skills. I'm in middle of learning lisp (elisp to be precise) and it feels like reading poetry. It's a transcendent experience that's hard to explain. Such beautiful concepts. Everything flows in a way it doesn't in C based langs

by FergusArgyll

5/18/2026 at 9:15:49 PM

The page indicates that there is not function for documentation in common lisp, but

  (documentation 'documentation 'function)
      "Return the documentation string of Doc-Type for X, or NIL if none 
        exists. 
        System doc-types are VARIABLE, FUNCTION, STRUCTURE, TYPE, SETF, and T.

 Also http://rosettacode.org for computer tasks implemented in many computer languages to allow you compare syntax and code.

by sinsudo

5/19/2026 at 1:14:50 AM

Likewise apropos. It's an ANSI function.

by dreamcompiler

5/18/2026 at 10:32:25 PM

Perhaps related, I'm maintaining a "cheatsheet" to let Python programmers see what an Elisp equivalent to typical Python functions/methods are.

https://kickingvegas.github.io/elisp-for-python/

by kickingvegas

5/18/2026 at 10:49:37 PM

Are `(push s x)` and `(push x s)` correct for push and insert, resp.?

by emil-lp

5/21/2026 at 2:27:41 AM

Oh dang, thanks for catching that. Will amend.

by kickingvegas

5/19/2026 at 9:02:20 AM

> cannot start with digit

Not only it can, but both CL and Emacs Lisp actually defines primitives with names that start with digit.

by dfox

5/18/2026 at 8:11:42 PM

Clojure 1.6, Emacs 24.5... These are pretty old versions, at least of those.

by eamonnsullivan

5/18/2026 at 11:43:40 PM

Emacs Lisp is a descendant of PDP-10 MAClisp, which makes it one of the oldest Lisp dialects still actively maintained. Whether it's version 24.5 or 30.2 doesn't make much of a difference semantically.

by rahen

5/18/2026 at 8:29:51 PM

Most of the things in that table won’t change from version to version anyway.

by db48x

5/19/2026 at 12:37:35 AM

To be fair I think the only real differences since 1.6 you’d see are transducer versions of some of what’s in here for Clojure. The stuff expressed here is all very basic.

by devin

5/19/2026 at 5:19:09 PM

There is a difference with the very first line item, though minor: "clojure --version" is available. True that transducers aren't going to be a part of this comparison.

by waffletower

5/19/2026 at 5:17:37 PM

I have been a clojurist for more than a decade and I started with Clojure 1.7. 1.6 was released in 2014!

by waffletower

5/19/2026 at 4:39:25 AM

CL list comprehension:

  (loop for file across "ABCDEFGH"
        nconc (loop for rank from 1 to 9
                    collect (format nil "~C~D" file rank)))

by aidenn0

5/19/2026 at 9:21:03 AM

Or with more Python-esque syntax:

    (let ((files (coerce "ABCDEFGH" 'list))
          (ranks (loop for r from 1 to 9 collect r)))
      [(format nil "~a~a" file rank) (file <- files) (rank <- ranks)])
Based on the list comprehension macro from 1991 in https://3e8.org/pub/scheme/doc/lisp-pointers/v4i2/p16-lapalm... that still works.

    (defmacro comp ((e &rest qs) l2)
      (if (null qs) `(cons ,e ,l2) ; rule A
          (let ((q1 (car qs))
                (q (cdr qs)))
            (if (not (eq (cadr q1) '<-)) ; a generator?
                `(if ,q1 (comp (,e ,@q) ,l2) ,l2) ; rule B
                (let ((v (car q1)) ; rule C
                      (l1 (third q1))
                      (h (gentemp "H-"))
                      (us (gentemp "US-"))
                      (us1 (gentemp "US1-")))
                  `(labels ((,h (,us) ; corresponds to a letrec
                              (if (null ,us) ,l2
                                  (let ((,v (car ,us))
                                        (,us1 (cdr ,us)))
                                    (comp (,e ,@q) (,h ,us1))))))
                     (,h ,l1)))))))

    (defun open-bracket (stream ch)
      (do ((l nil)
           (c (read stream t nil t)(read stream t nil t)))
          ((eq c '|]|) `(comp ,(reverse l) ()))
      (push c l)))

    (defun closing-bracket (stream ch) '|]|)

    (set-macro-character #\[ #'open-bracket)
    (set-macro-character #\] #'closing-bracket)
Supports filtering too, e.g.

    (let ((xs '(1 2 3 4))
          (ys '(1 2 3 4)))
      [(+ x y) (x <- xs) (y <- ys) (evenp x) (oddp y)])
    ; -> (3 5 5 7)

by Jach

5/20/2026 at 12:08:57 AM

I didn't try macroexpanding it yet, but when I make the 9 a runtime-parameter, I eventually get a stack-overflow with SBCL not TCO-ing the "H" binding in labels.

The comments make me think this is ported from scheme, which has precise TCO rules.

[edit] macroexpanded:

    (LABELS ((H-37 (US-38)
               (IF (NULL US-38)
                   NIL
                   (LET ((FILE (CAR US-38)) (US1-39 (CDR US-38)))
                     (LABELS ((H-43 (US-44)
                                (IF (NULL US-44)
                                    (H-37 US1-39)
                                    (LET ((RANK (CAR US-44)) (US1-45 (CDR US-44)))
                                      (CONS (FORMAT NIL "~a~a" FILE RANK) (H-43 US1-45))))))
                       (H-43 RANKS))))))
      (H-37 FILES))

by aidenn0

5/18/2026 at 8:57:36 PM

This is really neat.

Something I've been meaning to do is try putting together a cross-lisp package manager -- if only because it'd be fun. Maybe it would favor code that could be readily run or eval'd or maybe with some sort of clj/cljs type dynamic dispatch for anything implementation specific.

by ethagnawl

5/18/2026 at 8:16:25 PM

Great chrestomathy! I opened a PR for my lisp, Loon: https://github.com/clarkgrubb/hyperpolyglot/pull/139

by ecto

5/18/2026 at 11:55:51 PM

With all due respect, if this page adds a column for everyone's personal Lisp, it'll be as wide as the Pacific.

by wk_end

5/19/2026 at 1:28:08 AM

They say ethics and aesthetics are one!

by ecto

5/18/2026 at 8:31:37 PM

Would be interesting to see how Jank is coming along in this space as well.

by arikrahman

5/18/2026 at 11:55:31 PM

Jank's just supposed to be Clojure with full compatibility, when mature.

by veqq

5/18/2026 at 9:44:04 PM

Nice comparison.

But makes me think we'd be better off if we all just focused on a single one, and grew it, made it better. Not having 4 versions of something almost identical. Fragmentation can hurt adoption.

by FrustratedMonky

5/18/2026 at 9:59:37 PM

That’s what Common Lisp is.

by db48x

5/18/2026 at 11:31:01 PM

You got downvoted, but you're correct. Obligatory XKCD: <https://xkcd.com/927/>

Personally I prefer lisp 1 languages, like scheme. Even there, though, there was a split over r6rs, so we got a bunch of mostly-like-r5rs schemes and racket.

Maybe the problem is that lisps are no longer popular enough to have a winning implementation! If there is one, though, then it's Common Lisp on SBCL.

by MathMonkeyMan

5/18/2026 at 10:52:36 PM

There are deep reasons for the variations, especially around (reader) macros.

by erichocean

5/18/2026 at 11:09:47 PM

They are as different from one another as Java is from C# is from JavaScript.

by ludston

5/19/2026 at 12:31:49 PM

So, not by much?

by FrustratedMonky