Preferred ruby idiom for passing a counter by reference

Question

I have a long-running, iterative method that is prone to errors based on external factors beyond my control. I want to keep a count of iterations successfully completed in the scope of the caller so that if the method blows up, the caller can use the number of successfully completed iterations as part of its error handling and reporting features. Since ruby is strictly pass-by-value (no need to argue about this, really), my options seem to be limited to passing a counter object (which seems too basic to deserve its own object) or a contrived counter array, e.g.:

counter = [0]
begin
    LongRunningStuff.error_prone_iterations(counter)
    puts "success! completed #{counter[0]} iterations"
rescue
    puts "failed! completed #{counter[0]} iterations"
end

This feels kludgey (at best), downright silly at worst. Any suggestions for something that's more ruby-ish?

Answer 1

If there's two rules in Ruby it's everything is an object, and every variable acts like a reference to an object. This might seem a little odd, but it's actually very consistent. In other languages which mix primitives and objects, references and values, there's often more confusion.

Instead of a clunky array with no intrinsic meaning, why not create a context object and pass that in? Example:

context = {
  counter: 0
}

SomeModule.method_call(context)
puts context[:counter]

You can even use things like OpenStruct to tidy this up a little:

require 'openstruct'
context = OpenStruct.new(counter: 0)

SomeModule.method_call(context)

puts context.counter

The more "Ruby" way to do this is to create a context class that provides more semantic meaning to what you're doing:

class CounterContext
  attr_reader :counter

  def initialize
    @counter = 0
  end

  def count!
    @counter += 1
  end
end

This way you can layer on a little light-weight abstraction and make your code much more readable. It also means with a method like count! you can easily stub in some debugging code if you want to find out who's triggering that method instead of trying to track down where the counter was incremented.