Where are the functional programming constructs: `every` and `some`? [duplicate]

Question

This question already has an answer here:

• Are there “All” and “Any” functions in Mathematica? 5 answers

Coming from other functional programming environments (e.g., Clojure) I've become accustomed to some functions that I haven't found equivalents for in Mathematica yet.

The two I reached for last night were every and some.

Every would return True if the provided predicate function is True for every element in the list. (and False otherwise)

Some would return True if the provided predicate function is True for at least one of the elements in the list. (and False otherwise)

Every[{2, 4, 6}, EvenQ]
(* would return True *)
Every[{2, 4, 5}, EvenQ]
(* would return False *)

Some[{2, 4, 6}, OddQ]
(* would return False *)
Some[{2, 4, 5}, OddQ]
(* would return True *)

Perhaps some version of these are built-in and I've failed to find them in the docs?

Or, can we get a once-and-for-all efficient and elegant implementation of these that we can all use?

Or, is such an implementation impossible? (I hope not :)

Kind thanks, as ever.

---

Apologies if this question has been asked before, I saw some similar things, but none of the existing questions satisfied me.

For example, the following three questions are related, but suffer variously from bad specification in the question and low quality answers:

• https://stackoverflow.com/questions/8512658/
• https://stackoverflow.com/questions/4181470/
• https://stackoverflow.com/questions/4911827/

Answer 1

Haven't looked into efficiency, but both types of behavior are easily implimented through a run of the mill Map:

every[list_, test_] := And @@ (test /@ list)
some[list_, test_] := Or @@ (test /@ list)

used as:

every[Range[10], EvenQ]
(* False *)
some[Range[10], EvenQ]
(* True *)

I suspect that the linked solution (https://stackoverflow.com/a/8512766/2142251) is close to the optimal you'll get, as it uses Select which short circuits on the test. From that method you would define them as:

every[list_, cond_] := Select[list, ! cond@# &, 1] === {};
some[list_, cond_] := Select[list, cond@# &, 1] =!= {};

Update:

So after doing some quick benchmarking of the two, I have no definitive conclusion on which method is better. The short circuit naturally outperforms when the check fails quickly but for full list checks map wins out. So Let's assume that a function like every will be used in situations where you'd reasonably expect everything to check half the time, then you're in a situation where the map is quicker for every, but select is quicker for some. All this is however just based on some quick and dirty timings, so anyone feel free to build upon my thoughts or tear them apart.

Answer 2

Pattern-based solution

every[list_, test_] := MatchQ[list, _[__?test]]
some[list_, test_] := MemberQ[list, _?test]

It is also from SO (especially Mr.Wizard's answer).

My tests show that it is as fast as the approach with Select (may be a bit faster).