I have a generic `retry` function that takes an `a...

# coroutines

[rocketraman]

I have a generic retry function that takes an action lambda. Is there a way for me to define this function in such a way that the action lambda can be either suspending or non-suspending depending on the caller?

[louiscad]

A suspend lambda can not suspend. The contrary is not possible, unless you want to go down the dark route of runBlocking

[rocketraman]

Yeah, a retry is a peculiar case, because if I make the lambda suspendable, then the tryAction function I call it in with all of the error handling logic has to be suspending as well. But if I make that suspending, then the retry function has to be suspending.

[rocketraman]

This is my current (slightly simplified) implementation:

fun <T> retry(maxAttempts: Int = 3,
  delay: Long = 1000,
  action: () -> T): T = tryAction(0, maxAttempts, delay, action)

fun <T> tryAction(currentAttempt: Int, maxAttempts: Int, delay: Long, action: () -> T): T {

  return try {
    action.invoke()
  } catch (e: Exception) {
    if (currentAttempt + 1 < maxAttempts) {
      if(delay > 0) try { Thread.sleep(delay) } catch (e: InterruptedException) { /* ignore */ }
      tryAction(currentAttempt + 1, maxAttempts, delay, action)
    } else {
      throw e
    }
  }
}

[rocketraman]

I'm thinking I'd like to make this all suspending (which means I can use delay there instead of sleep also), and then have a retryBlocking wrapper for non-suspending callers.

[elizarov]

Yes. That is the way to do it.