如何编写重试函数？Scala中最多k次重试的函数实现问询

嘿，这个需求用Scala的函数式风格就能很优雅地解决，甚至还能做尾递归优化避免栈溢出。让我一步步给你拆解实现思路：

首先明确核心需求：我们的retry函数要接收最大重试次数k，以及一个Int => Try[Int]类型的目标函数，最多调用目标函数k次——只要某次返回Success就立刻返回结果；如果所有k次调用都失败，就返回最后一次的Failure。

基础递归实现 #

先写最直观的递归版本，逻辑清晰易懂：

import scala.util.Try

def retry(k: Int)(fun: Int => Try[Int]): Int => Try[Int] = (input: Int) => {
  val result = fun(input)
  result match {
    case s @ scala.util.Success(_) => s
    case f if k > 1 => retry(k - 1)(fun)(input)
    case f => f
  }
}

这里我把retry设计成返回Int => Try[Int]的形式，这样你可以先指定重试次数，得到一个带重试逻辑的包装函数，之后再传入具体的Int参数调用，更符合函数式编程的风格。如果你想让retry直接接收Int参数，也可以调整成这种形式：

def retry(k: Int)(input: Int)(fun: Int => Try[Int]): Try[Int] = {
  val result = fun(input)
  result match {
    case s @ scala.util.Success(_) => s
    case f if k > 1 => retry(k - 1)(input)(fun)
    case f => f
  }
}

尾递归优化版本 #

如果你的重试次数k可能很大，基础递归可能会导致栈溢出。这时候我们可以借助Scala的@tailrec注解实现尾递归优化，让编译器把递归转换成循环：

import scala.util.Try
import scala.annotation.tailrec

def retry(k: Int)(fun: Int => Try[Int]): Int => Try[Int] = (input: Int) => {
  @tailrec
  def attempt(remaining: Int): Try[Int] = {
    val result = fun(input)
    result match {
      case s @ scala.util.Success(_) => s
      case _ if remaining > 1 => attempt(remaining - 1)
      case f => f
    }
  }
  attempt(k)
}

这里把递归逻辑封装在内部的attempt函数里，每次递归调用都是函数的最后一步操作，编译器会自动优化成循环，彻底避免栈溢出问题。

测试验证效果 #

我们可以写一个模拟失败的测试函数，验证重试逻辑是否符合预期：

var attemptCount = 0
def flakyFoo(n: Int): Try[Int] = {
  attemptCount += 1
  // 前两次调用失败，第三次成功
  if (attemptCount < 3) Try.failure(new RuntimeException(s"Attempt $attemptCount failed"))
  else Try.success(n * 2)
}

// 测试重试3次的场景
val successResult = retry(3)(flakyFoo)(5)
println(successResult) // 输出：Success(10)
println(attemptCount)  // 输出：3（刚好第三次调用成功）

// 测试重试2次的场景
attemptCount = 0
val failedResult = retry(2)(flakyFoo)(5)
println(failedResult) // 输出：Failure(java.lang.RuntimeException: Attempt 2 failed)

这样就完全满足你的需求了：只要有一次调用成功就返回Success，否则返回最后一次的Failure。

内容的提问来源于stack exchange，提问作者Michael