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

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

> - 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)

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.

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.

  (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.

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

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

Likewise apropos. It's an ANSI function.

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

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.

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

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.

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

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)

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

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

That’s what Common Lisp is.

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

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