Question

是否有一种函数/ Scala方法可以重复调用函数，直到成功为止，同时对失败的尝试做出反应？

让我举一个例子来说明。假设我想从标准输入读取一个整数，如果用户实际上没有输入整数，则重试。

鉴于此功能：

def read_int(): Either[String, Int] = {
  val str = scala.io.StdIn.readLine()
  try {
    Right(str.trim().toInt)
  } catch {
    case _: java.lang.NumberFormatException => Left(str)
  }
}

这个匿名函数：

val ask_for_int = () => {
  println("Please enter an Int:")
  read_int()
}

val handle_not_int = (s: String) => {
  println("That was not an Int! You typed: " + s)
}

我会像这样使用它们：

val num = retry_until_right(ask_for_int)(handle_not_int)
println(s"Thanks! You entered: $num")

我的问题是：

Scala中是否存在类似retry_until_right的内容？
可以用现有设施解决吗？（Streams，Iterators，Monads等）
任何FP库（scalaz？）都提供这样的东西吗？
我可以做更好/更惯用的事吗？（*）

谢谢！

*）除了snake_case。我真的喜欢它。

Answer 1

我认为Try monad和Iterator.continually方法适合这个一般问题。当然，如果您愿意，可以采用这个答案来使用Either：

def retry[T](op: => Try[T])(onWrong: Throwable => Any) = 
    Iterator.continually(op).flatMap { 
        case Success(t) => Some(t)
        case Failure(f) => onWrong(f); None 
    }.toSeq.head

然后你可以这样做：

retry { Try(scala.io.StdIn.readLine.toInt) }{ _ => println("failed!") }

或者你甚至可以隐藏实现的Try部分，并给onWrong一个默认值，并使其成为第二个参数而不是curried函数：

def retry[T](op: => T, onWrong: Throwable => Any = _ => ()) = 
    Iterator.continually(Try(op)).flatMap { 
        case Success(t) => Some(t)
        case Failure(f) => onWrong(f); None 
    }.toSeq.head

那么你可以简单地说：

retry { scala.io.StdIn.readLine.toInt } { _ => println("failed") }

或者

retry { scala.io.StdIn.readLine.toInt }

Answer 2

这是使用scalaz.concurrent.Task的替代解决方案：

import scalaz.concurrent.Task

def readInt: Task[Int] = {
  Task.delay(scala.io.StdIn.readLine().trim().toInt).handleWith {
    case e: java.lang.NumberFormatException =>
      Task.delay(println("Failure!")) flatMap (_ => readInt)
  }
}

重试包装器（稍微不那么灵活）：

def retry[A](f: Task[A])(onError: PartialFunction[Throwable, Task[_]]): Task[A] =
  f handleWith (onError andThen (_.flatMap(_ => retry(f)(onError))))

val rawReadInt: Task[Int] = Task.delay(scala.io.StdIn.readLine().trim().toInt)

val readInt: Task[Int] = retry(rawReadInt) {
  case e: java.lang.NumberFormatException => Task.delay(println("Failure!"))
}

说明

scalaz.concurrent.Task[A]是一个monadic结构，最终返回A。它使用蹦床（通常）避免堆栈溢出。它还处理异常，可以重新抛出异常，也可以通过\/（scalaz的右偏Either）表示异常。

handleWith允许我们为Throwable提出的Task编写处理程序。此处理程序的结果是之后运行的新Task。在这种情况下，我们只会打印出错误消息，然后使用Task再次调用原始flatMap。由于Task是一个蹦床构造，因此应该是安全的。

尝试使用readInt.run - 这将在当前线程上运行任务，并最终返回传入的Int值。

Answer 3

这是我的第一个尾递归实现：

@scala.annotation.tailrec
def retry_until_right[WRONG, RIGHT](generator: () => Either[WRONG, RIGHT])(on_wrong: WRONG => Any): RIGHT = {
  generator() match {
    case Right(right) =>
      right
    case Left(wrong) =>
      on_wrong(wrong)
      retry_until_right(generator)(on_wrong)
  }
}

但是想要重用现有的库，我接着使用迭代器切换到这种方法：

def retry_until_right[WRONG, RIGHT](generator: => Either[WRONG, RIGHT])(on_wrong: WRONG => Any): RIGHT =
  Iterator.continually(generator).flatMap {
    case Left(value) =>
      on_wrong(value)
      None
    case Right(value) =>
      Some(value)
  }.toSeq.head

可以这样使用：

val num = retry_until_right(ask_for_int()) { str =>
  println("Ivalid input: " + str)
}
println("Thanks! You entered: " + num)

然而，可以说，在实现中隐藏Iterator的普通视图可能是不灵活的。如果开发人员想要对其进行进一步操作怎么办？（映射等）

相反，对“错误”值做出反应并最终选择第一个“正确”值的操作可以被抽象为特定于Either[L,R]类型的迭代器的“扩展”类，如下所示：

implicit class EitherIteratorExtensions[L, R](it: Iterator[Either[L, R]]) {
  def onLeft(callback: L => Any) =
    it.map {
      case left @ Left(value) =>
        callback(value)
        left
      case right => right
    }

  // take only Right elements
  def takeRight: Iterator[R] = 
    it.flatMap {
      case Left(_) =>
        None
      case Right(value) => Some(value)
    }

  // iterate and fetch the first Right element
  def firstRight: R = {
    takeRight.toSeq.head
  }
}

现在我们可以用简洁的代码轻松地使用所需的方法，同时保持对Iterator的控制，如下所示：

val num = Iterator.continually(ask_for_int()).onLeft(handle_not_int).firstRight

println("Thanks! You entered: " + num)

虽然我对这种方法感到满意，但我仍然想知道这不是现有库的一部分 已经 ......

Answer 4

def retry[L, R](f: => Either[L, R])(handler: L => Any): R = {
    val e = f
    e.fold(l => { handler(l); retry(f)(handler) }, identity)
}

Answer 5

可以在此处找到重试monad的实现： https://github.com/hipjim/scala-retry 它有各种重试策略。

// define the retry strategy
implicit val retryStrategy =
    RetryStrategy.fixedBackOff(retryDuration = 1.seconds, maxAttempts = 2)

// pattern match the result
val r = Retry(1 / 1) match {
    case Success(x) => x
    case Failure(t) => log("I got 99 problems but you won't be one", t)
}

已经存在重试的功能方式 - 直到Scala？

5 个答案:

说明