Do all? and any? guarantee short-circuit evaluation?

Question

Testing out some code in both pry and irb, I get the following results:

[1] pry(main)> a = [1, 3, 5, 7, 0]
=> [1, 3, 5, 7, 0]
[2] pry(main)> a.any? {|obj| p obj; 3 / obj > 1}
1
=> true
[3] pry(main)> a.all? {|obj| p obj; 3 / obj > 1}
1
3
=> false

In [2] and [3] I see that there appears to be short-circuit evaluation that aborts the iteration as soon as possible, but is this guaranteed behaviour? Reading the documentation there is no mention of this behaviour. I realise that I can use inject instead as that will iterate over everything, but I'm interested in finding out what the official Ruby view is.

Answer 1

Yes.

In the final draft of the Ruby standard, all? is defined as such:

1. Invoke the method each on the receiver
2. For each element X which the method each yeilds:
   1. If block is given, call block with X as argument. If this call returns a falseish object, return false.
   2. If block is not given, and X is a falseish object, return false.
3. Return true.

Note the word return in step 2. This guarantees short circuit evaluation. any? is defined similarly. However the standard is still a draft and I don't know which Ruby implementations (if any) aim to be standards-compliant.

Answer 2

The any? method just realizes the 'or' logic function over the Enumerable. It could be interpreted as statement:

y = x1 v x2 v x3 v ... v xn

And the all? method realizes 'and' logic function over the Enumerable. It also could be interpreted as statement:

y = x1 * x2 * x3 * ... * xn

Since the Array is an Enumerable, it also includes those methods. So, for the method any? the first occurience of true (exactly neither nil nor false) result breaks enumeration with true result. In example the yielded becomes true on number 4, so the methods breaks the execution the returns true:

[1,2,3,4,5].any? {| x | puts x ; x > 3 }
# 1
# 2
# 3
# 4
# => true

Also you can apply DeMorgan's rule to the function any?, and to use all? method:

![1,2,3,4,5].all? {| x | puts x ; x <= 3 }
# 1
# 2
# 3
# 4
# => true

For the method all? the first occurience of either false or nil result do something similar, i.e. returns false. In example the yielded becomes false on number 3, so the methods breaks the execution the returns false:

[1,2,3,4,5].all? {| x | puts x ; x < 3 }
# 1
# 2
# 3
# => false

And with DeMorgan's transformation to use any? method:

![1,2,3,4,5].any? {| x | puts x ; x >= 3 }
# 1
# 2
# 3
# => false

Answer 3

I think there is some ambiguity here.

Consider the following:

RUBY_VERSION
=> "2.3.7"

When yielding to a block:

[1,2,3,4,5].all? {| x | puts x ; x < 3 }
# 1
# 2
# 3
# => false

When not yielding to a block:

def a
  puts "in a"
  true
end

def b
  puts "in b" 
  false
end

def c
  puts "in c"
  true
end

[a,b,c].all?
# in a
# in b
# in c
# => false

Seems like condition #2:

If block is not given, and X is a falseish object, return false.

Is not valid.