[metroholografix]

Loop works well, is widely used, also available in Emacs Lisp and comes with zero dependencies. For these reasons, I don't see this gaining much traction.

Anecdote: In almost 20 years of CL usage, I've never needed an extensible iteration construct. I also find 'loop' a lot more readable than 'iterate' [1], another fad that has come and gone.

[1] https://iterate.common-lisp.dev

[phforms]

TIL that there is a whole package for “Common Lisp Emulation”[1] in Emacs that adds functions and control structures from CL “to make Emacs Lisp programming significantly more convenient”. Never developed a package for Emacs myself, but I feel like this can be of great help if I ever wanted to.

I know that there are projects like Lem[2] that try to build some kind of editor (Emacs-like, I guess) on top of CL, which made me wonder if we would have a CL-based Emacs today if it would have been standardized by the time and if this would have been a better choice than creating a custom dialect.

[1]: https://www.gnu.org/software/emacs/manual/html_node/cl/ (C-h R "cl" in Emacs)

[2]: https://lem-project.github.io

[cmrdporcupine]

I'd say that lem is an emacs. Emacs is a genus, not a species. Before GNU Emacs (& XEmacs) there were others. And I'd classify lem as another.

[lispm]

> I'd say that lem is an emacs. Emacs is a genus, not a species.

The question is what makes this species.

For example see https://www.finseth.com/craft/#c10.1

It's the command set (key bindings, extended commands, ...), buffers with modes and minor modes, the user interface for buffers, marks, the "cursor", extensibility, ...

For example in a typical Emacs the "cursor" / current mark is always visible, even in GUI versions. This is very different from other editors, where the current cursor can be non visible.

Basically there are a lot of similarities between the early Emacs editors (EMACS, EINE/ZWEI/ZMACS, Multics Emacs, ... and others).

Does LEM try to be similar to an EMACS editor or is it only emulating one on demand?

GNU Emacs use might also think of Emacs Lisp as an extension language, a GUI version, menubars with menus, self-documentation, ...

[cmrdporcupine]

Theological questions. The reality is that one "knows an emacs when one sees it." And lem behaves like GNU Emacs in some fundamental respects. Default keybindings, buffer management, macros, etc. Even newer things like lsp support + modes, etc.

It is not clear to me why the marketing for lem is "a Lisp IDE" when it clearly is "an emacs written in Common Lisp"

[remexre]

In what sense is iterate a fad that was gone? I see 1161 systems in Quicklisp (out of 5499 total) that transitively depend on iterate; so about a fifth of the open-source ecosystem.

[Jtsummers]

Transitive dependencies are a poor indicator of actual utilization. How many direct dependencies are there?

For what it's worth, I quit using it since it broke if you ever used the CL function `count` inside an iterate construct. Reportedly it was fixed, but it's still failing to work correctly using the Quicklisp version (just installed CL on and setup QL since it's a new laptop, so it shouldn't be pulling an old version). It was fun for a while, but having to remember "Oh yeah, don't use count" every time I reached for it for something natural was annoying and not worth bothering with.

[remexre]

It has 201 direct dependencies, making it the 9th most directly-depended-on system in Quicklisp, one spot ahead of UIOP.

Methodology (yes, I could've stayed in Lisp, but I started by awking systems.txt...):

    (with-open-file (*standard-output* #p"deps.txt" :direction :output)
      (iter
        (for system in (ql:provided-systems t))
        (for name = (ql::name system))
        (format t "~a ~a~%" (length (ql:who-depends-on name)) name)))

    $ sort -h deps.txt | tail
    200 uiop
    201 iterate
    206 split-sequence
    274 closer-mop
    344 cl-glfw-opengl-core
    350 bordeaux-threads
    387 fiveam
    391 cffi
    408 cl-ppcre
    1006 alexandria

[a-french-anon]

I find iterate much better on the other hand. Especially the part where I don't have to use :do to switch back to CL syntax and I can use the usual nested if else without having to remember the :end/:then stuff.