What to use instead of find-if?

[Rupert Swarbrick]

--=-=-=

I was messing around last night and added a small feature to my local
copy of gnus. Cool. I reckon it'd be useful in general, so I was going
to post it to ding. Cool.

However

Looking back at the code, I realised I used cl's find-if (I know
somewhat more common lisp than elisp). And gnus doesn't (require
'cl). So the code I'm thinking about does the following:

(let ((blah
(find-if (lambda (elem)
(whopping-great-predicatey-thing))
some-list)))
(if blah
(something using blah)
(something else)))

Can anyone suggest a vaguely idiomatic way to do this using the built-in
constructs of elisp? This is a genuine question, by the way. I'm sure
I'm being thick not spotting a neat way to write this.

Rupert

--=-=-=
Content-Type: application/pgp-signature

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)

iJwEAQECAAYFAkk0QOwACgkQRtd/pJbYVoYc6AP8CbG17u+2UZ5hGcbnBS5C29u2
bQLnTpigHQHn1zXrIsdhDYqwSW9iB3zof+F/MQVVr728chiXTRiq8OlHdwktUmrR
7zJReKLxz6DKiw456ymuLLV7rnfU4O3u9l8CtTCecS85D6eDSSP6Ia5c5Z7dfTPc
IekoKQsg37B26FlVm0k=
=mS8x
-----END PGP SIGNATURE-----
--=-=-=--

[Rupert Swarbrick]

[Drew Adams]

> So the code I'm thinking about does the following:
> (let ((blah (find-if (lambda (elem)
> (whopping-great-predicatey-thing))
> some-list)))
> (if blah (something using blah) (something else)))
>
> Can anyone suggest a vaguely idiomatic way to do this using
> the built-in constructs of elisp?

There are no doubt lots of ways to do it. Here's one:

(defun my-find-if (pred xs)
(catch 'my-found
(dolist (x xs) (when (funcall pred x) (throw 'my-found x)))
nil))

[Rupert Swarbrick]

"Drew Adams" <drew....@oracle.com> writes:

Ahah. That's neat! (And is indeed the semantics I had in mind when I
wrote the original).

Now, this really isn't relevant to the original question, but I was just
wondering: what are the performance costs of (catch ) in elisp? For
example, should one think twice before using it in syntax highlighting
code or the like?

Rupert

[Drew Adams]

> > There are no doubt lots of ways to do it. Here's one:
> > (defun my-find-if (pred xs)
> > (catch 'my-found
> > (dolist (x xs) (when (funcall pred x) (throw 'my-found x)))
> > nil))
>
> Ahah. That's neat! (And is indeed the semantics I had in mind when I
> wrote the original).
>
> Now, this really isn't relevant to the original question, but
> I was just wondering: what are the performance costs of (catch )
> in elisp? For example, should one think twice before using it in
> syntax highlighting code or the like?

Sorry, I can't answer that.
My guess is that it is very performant.

I know that I don't think twice about using it.
But then I don't think twice about a lot of things. ;-)