Re: Advantage using mapc over dolist

[Jean Louis]

* Tomas Hlavaty <tom@logand.com> [2024-12-03 10:36]:
> On Tue 03 Dec 2024 at 09:13, Jean Louis <bugs@gnu.support> wrote:
> > * Tomas Hlavaty <tom@logand.com> [2024-12-03 00:21]:
> >> On Mon 02 Dec 2024 at 23:50, Jean Louis <bugs@gnu.support> wrote:
> >> >> hmm, somebody renamed it to cl-ecase and cl-case
> >> >> similar to flet -> cl-flet and labels -> cl-labels
> >> >> what a shame
> >> >
> >> > I find it liberating.
> >> 
> >> What do you mean?
> >> Could you explain that?
> >> 
> >> Emacs is switching to lexical scope and degraded two of the most lexical
> >> scope related things to secodary citizens.
> >
> > I am an Emacs Lisp programmer, and all Common Lisp functions prefixed with 
> > `cl-` I find liberating in the sense that personally within Emacs Lisp I do 
> > not like mixing it because it is not Common Lisp. All my software was first 
> > in Common Lisp, I know it and use it every day, I am a heavy user of my own 
> > Common Lisp. But within Emacs, I like using Emacs Lisp pure—it is a 
> > personal choice.

But Tomas, I mentioned nothing about pcase. I said cl- namespace being
separate feels liberating to me as my personal choice. If you wish to
use those commands without cl-prefix, there is solution that Stefan
wrote in recent email.

> I do not understand this explanation.  It feels like renaming car and
> cdr because it feels liberating.

It can be. Lisp is all about making it right for you. I actually like
that `first' is now `cl-first', but if I wish to use it, I can simply
alias it.

You could make list and alias functions and you are fine.

> Beginners have been nagging about this for maybe 60 years already.

Congrats!

> iirc flet, labels, case, ecase predate Common Lisp and were present
> in ancient Emacs Lisp too (but I am not a Lisp historian).  Moving
> to lexical scoping and at the same time incompatibly renaming those
> fundamental lisp forms seems silly to me.

I don't know lexical, but what I know is that I have no problems with
lexical, and those global packages still work. I have one of them, I
keep it global, and I am fine with it all. 

> They do not even have keyword arglist.  Anytime I process complex
> data recursively, I reach for labels.  There does not seem to be an
> alternative, does it? 

I have no idea about it, let me see what AI says:

In **Common Lisp**, `labels` is a powerful macro used for defining **local 
functions**, including those that are **mutually recursive**. This is 
particularly useful when working with **recursive algorithms** or **complex 
data processing**, as it allows you to encapsulate helper functions within the 
scope of another function without polluting the global namespace.

### **Common Lisp `labels`**

#### **Usage Example:**

```lisp
(defun compute-factorials (numbers)
  (labels ((factorial (n)
             (if (<= n 1)
                 1
                 (* n (factorial (1- n))))))
    (mapcar #'factorial numbers)))
```

In this example:

- **`labels`** defines a local function `factorial` within `compute-factorials`.
- The `factorial` function can call itself recursively.
- This setup keeps the `factorial` function **encapsulated**, preventing it 
from being accessible outside `compute-factorials`.

### **Emacs Lisp and `labels`**

While **Emacs Lisp** does not natively support `labels` as Common Lisp does, it 
provides similar functionality through the **Common Lisp extensions** available 
in Emacs via the `cl-lib` package. Specifically, you can use `cl-labels` to 
achieve the same effect.

#### **Using `cl-labels` in Emacs Lisp:**

1. **Enable `cl-lib`:**

   Make sure to require the `cl-lib` package at the beginning of your Emacs 
Lisp file or session:

   ```elisp
   (require 'cl-lib)
   ```

2. **Define Local Functions with `cl-labels`:**

   ```elisp
   (cl-labels ((factorial (n)
                  (if (<= n 1)
                      1
                    (* n (factorial (1- n))))))
     (mapcar #'factorial '(1 2 3 4 5)))
   ```

   In this example:

   - **`cl-labels`** is used to define a local `factorial` function within the 
scope.
   - The `factorial` function can recursively call itself.
   - The local function remains **private** to the `cl-labels` block.

### **Alternatives to `labels`**

If you prefer not to use `cl-labels`, there are alternative approaches to 
handle recursion and complex data processing in both Common Lisp and Emacs Lisp:

1. **Global Function Definitions:**

   Define helper functions globally. This is straightforward but can lead to 
namespace pollution.

   ```lisp
   (defun global-factorial (n)
     (if (<= n 1)
         1
         (* n (global-factorial (1- n)))))
   
   (defun compute-factorials (numbers)
     (mapcar #'global-factorial numbers))
   ```

2. **Anonymous Functions and Closures:**

   Use lambda expressions and closures to encapsulate functionality.

   ```lisp
   (defun compute-factorials (numbers)
     (let ((factorial (lambda (n)
                        (if (<= n 1)
                            1
                          (* n (funcall factorial (1- n)))))))
       (mapcar factorial numbers)))
   ```

   *Note: In Emacs Lisp, this approach can be more cumbersome due to the way 
closures handle recursion.*

3. **Higher-Order Functions:**

   Utilize higher-order functions to pass recursive behavior as arguments.

   ```lisp
   (defun compute-factorials (numbers)
     (mapcar (lambda (n)
               (labels ((factorial (n)
                          (if (<= n 1)
                              1
                            (* n (factorial (1- n))))))
                 (factorial n)))
             numbers))
   ```

### **Conclusion**

- **`labels` in Common Lisp**: Essential for defining local, potentially 
recursive functions within a function's scope.
- **`cl-labels` in Emacs Lisp**: Provides similar functionality through the 
`cl-lib` package, allowing local and recursive function definitions.
- **Alternatives**: While global definitions and other methods exist, `labels` 
and `cl-labels` offer a clean and encapsulated way to handle recursion and 
complex data processing.

**Therefore, when dealing with recursive processing in Common Lisp or Emacs 
Lisp, `labels` (or `cl-labels` in Emacs) remains one of the most effective and 
idiomatic solutions.**

---

So I would say, I would not get frustrated, rather just make an alias
for me and use `labels' wherever I wish and want.

> That means infecting my code with cl-lib silliness.

I understand your feelings, but same could be said when you use any
Emacs package, the namespaces are not same as in Common Lisp, so it is
to be swallowed. Today is cl- and tomorrow is something else like lc-
or rcd- or rms- whatever. 

> And how infecting Emacs with pcase monstrosity feels liberating
> compared to simple case and ecase?

I have no single use of `pcase' but I know what it does. I like so much `cond'.

-- 
Jean Louis