Re: How to mapcar or across a list?

[Marcin Borkowski <mbork@mbork.pl>]

On 2015-07-15, at 22:45, Pascal J. Bourguignon <pjb@informatimago.com> wrote:

> Marcin Borkowski <mbork@mbork.pl> writes:
>
>> Hi there,
>>
>> so here's my problem: I have a list of Boolean values, and I want to
>> `mapcar' an `or' across it (IOW, I want to test whether at least one of
>> them is true).  Of course, (apply #'or my-list) does not work.  Of
>> course, I can (cl-reduce (lambda (x y) (or x y)) my-list) -- but is
>> there a better method?
>>
>> BTW, my-list doesn't really exist: it is a result of `mapcar'ing
>> a function taking some value and yielding a Boolean value, so bonus
>> points if the method does not process the whole list.
>
> It's too late, lisp is not a lazy language.

Well, *after* I mapcar then it's too late, but your own answer (below)
shows that mapcar itself is not necessary (as I suspected).

>> (Note: I just noticed that my-list is in fact sorted so that all true
>> values (if any) will occur at the beginning anyway, so I can just test
>> the first one.  This means that my problem is purely academic, though
>> still interesting, I guess.)
>
> First you want to reduce a list of booleans to a single value, so what
> makes you thing that mapcar is the right too for that?  There's the word
> "map" in "mapcar", didn't you notice?

My bad, you're right, of course.

>        map           reduce
>
>     x1 --> r1       x1 -\
>     x2 --> r2       x2 --+-> r
>     x3 --> r3       x3 -/

Please, do not shame a mathematician.  I hope notany (pun intended;-))
of my students will read this...

> Also, mapcar allocates a new list of same length as the original list
> for the result, so it is costly.  At least, you could consider mapc.

True.

> With mapc (or mapcar) you could perform your task with some cl magic:
>
>     (require 'cl)
>     (setf lexical-binding t)
>
>     (defun* or-all (list)
>        (mapc (lambda (element)
>                 (when element
>                   (return-from or-all t)))
>              list)
>        nil)
>
>     (defun* and-all (list)
>        (mapc (lambda (element)
>                 (unless element
>                   (return-from and-all nil)))
>              list)
>        t)
>
>     (or-all '(nil nil nil)) --> nil
>     (or-all '(nil t   nil)) --> t 
>
>     (and-all '(t   t   t)) --> t
>     (and-all '(t   nil t)) --> nil 
>
>
> But I fail to see how it's better than:
>
>     (defun* or-all (list)
>        (reduce (lambda (a b) (or a b)) list))
>
>     (defun* and-all (list)
>        (reduce (lambda (a b) (and a b)) list))

Of course, but - as I expected - someone already felt that there should
be a more elegant way, and hence the abstraction called `some', `every' etc.

> or than just:
>
>    (some     'identity '(nil nil nil)) --> nil
>    (some     'identity '(nil t   nil)) --> t
>    (some     'identity '(t   t   t  )) --> t
>
>    (every    'identity '(nil nil nil)) --> nil
>    (every    'identity '(t   nil t  )) --> nil 
>    (every    'identity '(t   t   t  )) --> t
>
> There are also the negations:
>
>    (notevery 'identity '(nil nil nil)) --> t
>    (notevery 'identity '(nil t   nil)) --> t
>    (notevery 'identity '(t   t   t  )) --> nil
>
>    (notany   'identity '(nil nil nil)) --> t
>    (notany   'identity '(t   nil t  )) --> nil 
>    (notany   'identity '(t   t   t  )) --> nil
>
> And since your booleans are computed by a function with mapcar, you
> could avoid computing this function for all the elements of the original
> list, and you could avoid allocating the temporary list by having some
> call this function:
>
>
> So instead of:
>
>     (reduce (lambda (a b) (or a b))
>             (mapcar 'complex-and-lengthy-predicate list))
>
> use:
>
>     (some 'complex-and-lengthy-predicate list)

How cool.  Again: I felt that something like that should exist, so I'm
not surprised that it actually does.

> For example:
>     (some (lambda (x) (print x) (evenp x)) '(1 2 3 5 7 9 11))
> prints:
>     1
>
>     2
> --> t
>
>
> Learn more about Common Lisp:
> http://www.lispworks.com/documentation/HyperSpec/Front/
> http://cliki.net/

Well, maybe I should.  I have a bunch of students who want to study CL,
I should be able to help them;-).  (I read parts of the Cl spec, most of
"Practical Common Lisp" and small parts of "On Lisp", but that was a few
years ago...)

Thanks again,

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University