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

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:

## marked as duplicate by rm -rf♦Oct 18 '13 at 23:32

• The answers to the questions you cited don't particularly strike me as being low quality. – Leonid Shifrin Oct 18 '13 at 22:45
• You're right, I should have left that subjective judgement out. – Harold Oct 18 '13 at 22:54
• Are Or and And are not suitable? – Daniel Lichtblau Oct 19 '13 at 21:24

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.

• Wow, so fast. Easy upvote, this is what I was trying to do, but I hadn't understood Prefix/@ or the third argument to Select before. I learned a lot, warm thanks. – Harold Oct 18 '13 at 22:28

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).