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

[Drew Adams <drew.adams@oracle.com>]

> (defun check-if-any-elt-is-non-nil (list)
>   (let (there-is)
>     (while (and list (not there-is))
>       (when (car list) (setq there-is t))
>       (setq list (cdr list)))
>     there-is))

Sure, that works.  That's the same as one of
the functions I sent without bothering with
the `let' variable:

(defun foo (xs)
  (while (and (not (car xs)) xs)
    (setq xs (cdr xs)))
  (car xs))

> (benchmark 10000000 (check-if-any-elt-is-non-nil (append (list 1) (make-
> list 1000000 nil)))) ⇒ "Elapsed time: 0.771948s"
> 
> (benchmark 10000000 (check-if-any-elt-is-non-nil (append (make-list
> 1000000 nil) (list 1) ))) ⇒ "Elapsed time: 0.744323s"

I don't see that - at all. Did you really not
quote the second arg to `benchmark'?  Anyway,
take the list creations out of your timings.
___

You might compare the times needed to create
your two lists.  `append' is not symmetric.

Dunno just how `append' is implemented in C.
But you can see from a recursive Lisp
definition how different the two list args
are treated:

(defun apnd (xs ys)
  (if (null xs)
      ys
    (cons (car xs) (apnd (cdr xs) ys))))

It cdrs down the first list, recursing, but
just conses onto the second list.  So it
takes longer with a long first list and a
short second one than with the args reversed.
It traverses only the first of its list args.
Things like this are good to keep in mind.

Compare by hand (apnd nil '(1 2 3)) with
(apnd '(1 2 3) nil).  The first is done as
soon as it starts - no recursion at all. The
second recurses once for each element of the
first list: (cons 1 (cons 2 (cons 3 nil)))

(benchmark 1000 '(append (list 1) (make-list 10000 nil)))
"Elapsed time: 2.032493s (1.942879s in 45 GCs)"

(benchmark 1000 '(append (make-list 10000 nil) (list 1)))
"Elapsed time: 4.165245s (3.944074s in 91 GCs)"