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))))
CodeArtisan 6 hours ago [-]
Shouldn't it be
(+ a (apply + b))
db48x 4 hours ago [-]
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.
ludston 5 hours ago [-]
Worse: Using recursion in Common Lisp isn't idiomatic, given that CL doesn't guarantee tail-call optimisation in the specification.
3 hours ago [-]
dreamcompiler 3 hours ago [-]
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.
ludston 48 minutes ago [-]
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.
vindarel 6 hours ago [-]
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.
- java interop: with LispWorks or ABCL (or other libraries)
my 2c
sinsudo 6 hours ago [-]
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.
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.
dreamcompiler 3 hours ago [-]
Likewise apropos. It's an ANSI function.
kickingvegas 6 hours ago [-]
Perhaps related, I'm maintaining a "cheatsheet" to let Python programmers see what an Elisp equivalent to typical Python functions/methods are.
Are `(push s x)` and `(push x s)` correct for push and insert, resp.?
eamonnsullivan 8 hours ago [-]
Clojure 1.6, Emacs 24.5... These are pretty old versions, at least of those.
devin 4 hours ago [-]
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.
rahen 5 hours ago [-]
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.
db48x 8 hours ago [-]
Most of the things in that table won’t change from version to version anyway.
ethagnawl 7 hours ago [-]
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.
With all due respect, if this page adds a column for everyone's personal Lisp, it'll be as wide as the Pacific.
ecto 3 hours ago [-]
They say ethics and aesthetics are one!
arikrahman 8 hours ago [-]
Would be interesting to see how Jank is coming along in this space as well.
veqq 4 hours ago [-]
Jank's just supposed to be Clojure with full compatibility, when mature.
FergusArgyll 6 hours ago [-]
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
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.
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.
ludston 5 hours ago [-]
They are as different from one another as Java is from C# is from JavaScript.
erichocean 5 hours ago [-]
There are deep reasons for the variations, especially around (reader) macros.
Rendered at 04:15:09 GMT+0000 (Coordinated Universal Time) with Vercel.
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.
Even with SBCL, for example, it doesn't have tail-call optimisation for all architectures at all optimisation levels.
- 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
(1) https://news.ycombinator.com/item?id=47779659
https://kickingvegas.github.io/elisp-for-python/
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.
https://www.gnu.org/software/emacs/manual/html_mono/cl.html
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.
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.