गिनें कि कितनी बार एक विधि को बुलाया जा सकता है जब तक कि वह शून्य वापस नहीं आती

पृष्ठभूमि: मुझे दूरस्थ स्थान में रिकॉर्ड की संख्या निर्धारित करने की आवश्यकता है। रिकॉर्ड क्रमिक रूप से गिने जाते हैं (0, कोई अंतराल पर शुरू) और केवल उनकी संख्या के आधार पर एक-एक करके प्राप्त किया जा सकता है।

नेटवर्क पर रिकॉर्ड लाने की विधि सफलता पर एक सच्चाई मान और विफलता पर एक फाल्सी मान लौटाती है। यहाँ एक उदाहरण है:

fetch_record(0) #=> true (record #0 exists)
fetch_record(1) #=> true (record #1 exists)
fetch_record(2) #=> true (record #2 exists)
fetch_record(3) #=> nil  (no record #3)

मैं यह बताने के लिए कि मैं nil (उपरोक्त उदाहरण में 3 बार) वापस आने तक बढ़ते तर्क के साथ कितनी बार fetch_record कॉल कर सकता हूं, एक सुरुचिपूर्ण तरीका खोजने की कोशिश कर रहा हूं।

मैंने अब तक क्या प्रयास किया है

परीक्षण उद्देश्यों के लिए इस सरलीकृत कार्यान्वयन को देखते हुए:

def fetch_record(index)
  raise if index > 3 # just to prevent endless loops
  true if index < 3
end

यहाँ मेरे प्रयास हैं:

1. एक while लूप एक स्पष्ट काउंटर चर के साथ स्पष्ट रूप से काम करेगा, लेकिन मैं बहुत मुहावरेदार नहीं दिखता:

   i = 0
   i += 1 while fetch_record(i)
   i
   #=> 3
   

2. मैं एक स्पष्ट परिणाम मान के साथ step और break का उपयोग कर सकता था लेकिन यह बोझिल लग रहा था:

   0.step(by: 1).each { |i| break i unless fetch_record(i) }
   #=> 3
   

3. एक आलसी व्यक्ति भी बुरा है:

   0.step(by: 1).lazy.map { |i| fetch_record(i) }.take_while(&:itself).count
   #=> 3
   

क्या उपरोक्त को पूरा करने का एक आसान तरीका है?