Re: [External] : Re: Testing whether a list contains at least one non-nil element

[Emanuel Berg <incal@dataswamp.org>]

Stefan Monnier via Users list for the GNU Emacs text editor wrote:

>> You don't want to implement such functions in Emacs with
>> recursion because you'll easily hit `max-lisp-eval-depth'
>> when they are called.
>
> Indeed (and it's significantly slower than the corresponding
> loop without function calls).

Recursion is slower because of the continual function calls
and those will also blow the stack eventually ...

>> Sorry to tell you, but a loop is the preferable way
>> in Elisp.
>
> Luckily, since Emacs-28 you can have your cake and eat it too:
>
>     (defun has-non-nil (lst)
>       (named-let loop ((lst lst))
>         (cond
>          ((null lst) nil)
>          ((consp lst) (or (not (null (car lst))) (loop (cdr lst))))
>          (t (error "Not a proper list! You cheater!")))))

`named-let' is from a "[l]ooping construct taken from Scheme."

I love it that Elisp is like a "Lisp dump" area where
everything from the Lisp world worth having seems to end up
eventually ...

> Admittedly, here the `named-let` construct gives you only
> the elimination of tail-recursion, but in many other
> circumstances it also leads to quite elegant code.

Here tail refers to not the `cdr' of the list but the tail of
the function, "a tail call is a subroutine call performed as
the final action of a procedure. If the target of a tail is
the same subroutine, the subroutine is said to be tail
recursive, which is a special case of direct recursion" [1]

I don't know why that is such an important distinction, I also
remember recursion over trees that recursed both ways from the
top and middle nodes if it/they had several child nodes, so
I guess that recursion was both tail and direct LOL.

Elisp direct recursion example anyone?

And what was this continuation-passing style?

  CPS 1975 continuation-passing style, coined in "AI Memo 349"

I used it once, but don't remember what file that was ...

> (defalias 'has-non-nil
>   #'(lambda (lst) [...]

TIL: In Scheme-inspired Elisp, quoting lambdas is OK ...

[1] https://en.wikipedia.org/wiki/Tail_call

-- 
underground experts united
https://dataswamp.org/~incal