It performs exactly as I would expect. In some cases the test you wish to run is very fast, so that it is faster to run that test on all the inputs and check the results after than it is to do the incremental checks needed for the short circuit.

As mentioned above, OddQ is written in low-level kernel code and is optimised when mapped:

In[13]:= list = RandomInteger[100, 10^6];

In[14]:= First@RepeatedTiming[OddQ /@ list]

Out[14]= 0.21808

In[15]:= oddQ[x_] := OddQ[x];

In[16]:= First@RepeatedTiming[oddQ /@ list]

Out[16]= 0.524905

But if running your predicate function is not as fast as OddQ then you do want to use avoid applying it to all elements of the list if possible.

Lastly, OddQ is listable, so you can be even faster by avoiding map:

In[17]:= First@RepeatedTiming[OddQ@list]

Out[17]= 0.0154204

I think the point is, if you already have a list of boolean values, list = {True, False, False, ....} then And @@ list is absolutely the right thing to do. AllTrue or any of the v9 implementations of it listed above would be overkill.

Jason is right; it doesn't short circuit. You see the difference in

And @@ ((Print[#]; EvenQ[#]) & /@ {2, 4, 6, 1, 3, 5})

versus

AllTrue[{2, 4, 6, 1, 3, 5}, (Print[#]; EvenQ[#]) &]

This shatters illusions.

I think Jason's point is that AllTrue short-circuits the Map. However, the timings suggest that it is slower. What am I missing?

test1 = {1}~Join~ConstantArray[2, 10^6];
test2 = ConstantArray[2, 10^6]~Join~{1};

allTrue[list_, test_] := test /@ list // MatchQ[{True ..}]
allTrueJason[list_, test_] := Catch[Map[Function[If[! test@#, Throw[False]]], list];
  True]

allTrue[test1, OddQ] // AbsoluteTiming
(* {0.204723, False} *)

allTrueJason[test1, OddQ] // AbsoluteTiming
(* {0.461795, False} *)

Similar timings for test2.

Careful. For conjunctions, Mathematica performs a short circuit evaluation, i.e. it stops anding up Booleans as soon as it encounters false. Btw this is standard procedure for any modern programming languages.

This is clearly the most Wolframian way of doing it, perhaps faster is And @@, but harder to read perhaps…

Interesting, if a bit more ... complicated.

[My kludge-y solution got it done in basically 2 lines with MemberQ[list, False] and then simply doing a check whether the output is "[Output]==False" to flip the output bit from False to True. ;) ]

As you can see, I simply took the row divisibility-by-row-number list ad did a MemberQ check versus "False," and then Simply did a check whether the check is false or not, which returns true if false, or false if true, to "invert" the value.

Ridiculous workaround. But, as long as it works, right? :P

Seriously though, is there an easier way to check that all list members are specifically true as opposed to "no members are false"?

I feel like there should be, save for the fact AllTrue[] apparently wasn't a thing in Mathematica 9 (I know, I'm a few versions back; been meaning to upgrade for a while, just haven't gotten around to it yet).