3

I'd like a function AnyTrue[expr,{i,{i1,i2,...}}] which checks if expr is True for any of i1,i2... It should be as if AnyTrue was Table followed by Or@@%, with the difference that it only evaluates expr until first True is found.

Short-circuiting part is optional, what I'd really like to know is the proper way to emulate Table's non-standard evaluation sequence.

Update 11/14

Here's a solution due to Michael, you can use it to chain "for all" and "there exists" checks

SetAttributes[AllTrue, HoldAll]; SetAttributes[AnyTrue, HoldAll]; AllTrue[{var_Symbol, lis_List}, expr_] := LengthWhile[lis, TrueQ[ReleaseHold[Hold[expr] /. HoldPattern[var] -> #]] &] == Length[lis]; AnyTrue[{var_Symbol, lis_List}, expr_] := LengthWhile[lis, Not[TrueQ[ReleaseHold[Hold[expr] /. HoldPattern[var] -> #]]] &] < Length[lis]; AllTrue[{a, {1, 3, 5}}, AnyTrue[{b, {2, 4, 5}}, EvenQ[a + b]]] AnyTrue[{a, {1, 3, 5}}, AllTrue[{b, {2, 4, 5}}, EvenQ[a + b]]]
Improve this question

2 Answers 2

Reset to default
5

How about this?

SetAttributes[AnyTrue, HoldAll]; AnyTrue[expr_, {var_Symbol, lis_List}] := LengthWhile[lis, Not[TrueQ[ReleaseHold[Hold[expr] /. HoldPattern[var] -> #]]] & ] < Length[lis]

Includes short-circuiting via LengthWhile and keeps everything held where necessary so that things work as expected with var has a value outside the function:

In[161]:= x = 777; In[162]:= AnyTrue[Print["x=", x]; x == 3, {x, {1, 2, 3, 4, 5}}] During evaluation of In[162]:= x=1 During evaluation of In[162]:= x=2 During evaluation of In[162]:= x=3 Out[162]= True

The built-in Or is short-circuiting, too, for what it's worth. (but I realize building up the unevaluated terms with e.g. Table is a pain):

In[173]:= Or[Print[1];True, Print[2];False] During evaluation of In[173]:= 1 Out[173]= True
Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

coming late, I'd just point out that excessive details in argument patterns do not often go well with Hold attributes. For example, the following call fails: AnyTrue[i < 10, {i, Range[5]}], while in principle it should not (the pattern does not match since at the pattern-matching time it does not know that Range[5] is List). This slightly more general signature will remove this problem: AnyTrue[expr_, {var_Symbol, lis_}]. Also, AnyTrue doesn't work in M8 on packed lists - there seems to be a bug in LengthWhile: LengthWhile[Range[5], ! TrueQ[# < 10] &] gives 5, am going to report it.
Yes, good point Leonid. It would be better to have a more general pattern and validate the argument after evaluating it. HoldAll instead of HoldFirst is necessary since we want to keep var held in addition to expr, otherwise there wouldn't be an issue with the more discerning pattern.
@Leonid -- I have just noticed the comment about PackedArray bug, and I wish I saw it earlier!..."@Yaroslav" would send notification to me, whereas Michael is notified automatically since comment is on his answer meta.stackexchange.com/questions/71903/…
@Yaroslav - Sorry, I thought the owner of the question is notified automatically. I should learn this SO mechanics better! Anyway, I wrote a similar function myself for my own uses a while ago, that one does not rely on LengthWhile and should be fine (but it suffers from the same pattern-matching problem as Michael's - could be fixed in principle) - see my reply to your post.
4

This doesn't match your spec but I often use the following utility functions, which are similar to what you have in mind (they use pure functions instead of expressions with a specified variable) and also do short-circuiting:

some[f_, l_List] := True === (* Whether f applied to some *) Scan[If[f[#], Return[True]]&, l]; (* element of list is True. *) every[f_, l_List] := Null === (* Similarly, And @@ f/@l *) Scan[If[!f[#], Return[False]]&, l]; (* (but with lazy evaluation). *)

For example, Michael Pilat's example would become this:

In[1]:= some[(Print["x=", #]; # == 3)&, {1, 2, 3, 4, 5}] During evaluation of In[1]:= x=1 During evaluation of In[1]:= x=2 During evaluation of In[1]:= x=3 Out[1]= True
Improve this answer

3 Comments

Useful trick. Note, using "If" instead of "TrueQ" requires a bit more care with syntax, ie every[False, {a, {1, 3, 5}}] gives "True"
You had me worried at first but I don't think there's a bug here. Note that the first argument needs to be a function. every[False&, {1,3,5}] works as expected.
Right, no bug, just a subtle semantic difference, since it's "True" if f evaluates to "something other than False" for every element of the list

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.