module Tins::Attempt

def attempt(opts = {}, &block)

of attempts.
Iff *reraise* is true the caught exception is reraised after running out

after a exponentially increasing duration of seconds.
seconds that is slept before giving up, and every attempt is retried
duration directly, in the latter case -*sleep* is the total number of
as seconds or a Numeric >= 0 or < 0. In the former case this is the
*sleep* is either a Proc returning a floating point number for duration

between attempts and catching the exception(s) in *exception_class*.
Attempts code in block *attempts* times, sleeping according to *sleep* 
def attempt(opts = {}, &block)
  sleep           = nil
  exception_class = StandardError
  if Numeric === opts
    attempts = opts
  else
    attempts        = opts[:attempts] || 1
    attempts >= 1 or raise ArgumentError, 'at least one attempt is required'
    exception_class = opts[:exception_class] if opts.key?(:exception_class)
    sleep           = interpret_sleep(opts[:sleep], attempts)
    reraise         = opts[:reraise]
  end
  return if attempts <= 0
  count = 0
  if exception_class.nil?
    begin
      count += 1
      if block.call(count)
        return true
      elsif count < attempts
        sleep_duration(sleep, count)
      end
    end until count == attempts
    false
  else
    begin
      count += 1
      block.call(count)
      true
    rescue *exception_class
      if count < attempts
        sleep_duration(sleep, count)
        retry
      end
      reraise ? raise : false
    end
  end
end

def compute_duration_base(sleep, attempts) 

def compute_duration_base(sleep, attempts)
  x1, x2  = 1, sleep
  attempts <= sleep or raise ArgumentError,
    "need less or equal number of attempts than sleep duration #{sleep}"
  x1 >= x2 and raise ArgumentError, "invalid sleep argument: #{sleep.inspect}"
  function = -> x { (0...attempts).inject { |s, i| s + x ** i } - sleep }
  f, fmid = function[x1], function[x2]
  f * fmid >= 0 and raise ArgumentError, "invalid sleep argument: #{sleep.inspect}"
  n       = 1 << 16
  epsilon = 1E-16
  root = if f < 0
           dx = x2 - x1
           x1
         else
           dx = x1 - x2
           x2
         end
  n.times do
    fmid = function[xmid = root + (dx *= 0.5)]
    fmid < 0 and root = xmid
    dx.abs < epsilon or fmid == 0 and return root
  end
  raise ArgumentError, "too many iterations (#{n})"
  result
end

def interpret_sleep(sleep, attempts) 

def interpret_sleep(sleep, attempts)
  if Numeric === sleep && sleep < 0 && attempts > 1
    sleep = -sleep
    duration_base = compute_duration_base sleep, attempts
    sleep = lambda { |i| duration_base ** i }
  end
  sleep
end

def sleep_duration(duration, count) 

def sleep_duration(duration, count)
  case duration
  when Numeric
    sleep duration
  when Proc
    sleep duration.call(count)
  end
end