Retry Loop Retry

This is fine. They take your software developer license away if you don’t periodically go on the internet and reply to something with an irrelevant nitpick.

Came to post exactly the same thing. If you’re time-bounding the loop, you can also nicely express it this way:

match action() {
  ok => return ok,
  err if permanent(err) || now().after(deadline) => return err,
  _ => continue, 
}

We both hand-waved away saving the first error, but it’s also not ever clear to me if that’s what I want in these situations.

There’s a difference between your two examples: the first does one retry if the count is 0; the other one doesn’t.

If your language supports tail call optimization, then the following works well (Lua, since it supports it):

local function attempt(data,count)
  assert(count >= 0)
  local okay,err = sendpacket(data)
  
  if okay                     then return true,0 end
  if not_transient_error(err) then return false,err end
  if count > 0                then sleep() return attempt(data,count-1) end
  return false,ETRIES
end

Even handles the 0 case without the “+1”. The assert() there is to signal that the count should be 0 or positive.

I like micro snippets that are hard to express like these, good little case studies for future PL designers

let rec retry f retries =
  match f () with
  | Error(e) if retries >= 0 && is_transient(e) => sleep(); retry f (retries - 1)
  | other => other

or

let rec retry f retries =
  match f () with
  | Error(e) => 
     if retries >= 0 && is_transient(e) then
        sleep(); retry f (retries - 1) 
     else 
        Error(e)
  | Ok(x) => Ok(x)

Maybe I misunderstand the requirements but wouldn’t the code in the post return the last error, not the original?

I personally prefer to count attempts upward from 1. This removes weird 0 attempts left situation:

Mobile pseudocode:

attemptNo = 1
while True:
  result = attempt()
  if attemptNo == maxAttempts: break result
  sleep()
  attemptNo++

I like to use the iterative monad transformer in Haskell for this:

void $ retract $ cutoff 10 $ untilJust do
  Dashboard.getProgramState dashboard >>= \case
    Dashboard.ProgramStopped -> return $ Just ()
    _ -> Nothing <$ liftIO (threadDelay 1_000_000)

Here I:

1. Run getProgramState, which can fail
2. If it fails, I add a 1s delay and return Nothing.
3. I wrap this in untilJust :: Monad m => m (Maybe a) -> IterT m a
4. I add a cutoff to limit the number of iterations: cutoff :: Monad m => Integer -> IterT m a -> IterT m (Maybe a)
5. I retract, to run the computation: retract :: Monad m => IterT m a -> m a

However, this doesn’t satisfy the requirements: there is a useless sleep at the end.

I think I’ve done it without the extra sleep by using <|> with an infinite list of delays (fun aside, you can generate this list to vary the delays at each step!). It was something like:

retract $ cutoff 10 $ untilJust tryTheThing <|> delay (untilJust (Nothing <$ threadDelay 1_000_000))

but I can’t find this in our code anymore, I guess I must have gotten rid of it.

Here’s my attempt, comes with two caveats:

1. action() is called in two places
2. retry_count is literally the retry count, so action is called up to retry_count + 1 times

    const result = try for (0..retry_count) |n| {
        break action() catch |err| {
            if (!transient(err)) break err;
            sleep(exp(n));
        };
    } else action();