柯里化的下限 - 可简化？

Question

我想利用 scalazs 析取将异常包装在自己的错误类型中。

以下代码应该可以编译

trait Result
trait Error extends Result
object MyError extends Error
object OK extends Result

val r: Error \/ OK.type = tryCatchIn(_ => MyError /*:Error*/) {
  val result: Error \/ OK.type = ???
  result
}

我想保留柯里化语法，不喜欢显式输入MyError。

我目前的解决方案是双重使用

  def tryCatchIn2[L, R](exceptionTransformer: Throwable => L, `finally`: => Unit = () => ()): CatchFinally[L] = {
    new CatchFinally(exceptionTransformer, `finally`)
  }

  class CatchFinally[L](val exceptionTransformer: Throwable => L, `finally`: => Unit = () => ()) {
    def apply[L2 >: L, R](block: => L2 \/ R): L2 \/ R = try {
      block
    } catch {
      case NonFatal(e) => -\/(exceptionTransformer(e))
    } finally {
      `finally`
    }
  }

我最初的柯里化方法会更好地反映我的意图，但我可以不让它发挥作用：

  def tryCatchIn[L, R, L2 >: L](exceptionContainer: Throwable => L, `finally`: => Unit = () => ())
                               (block: => L2 \/ R): L2 \/ R = {
    try {
      block
    } catch {
      case NonFatal(e) => -\/(exceptionContainer(e))
    } finally {
      `finally`
    }
  }

是否有更清晰的解决方案？

Answer 1

也许我错过了你的一些意图，但这段代码不是更简单吗：

def tryCatchIn[L, R](exceptionContainer: Throwable => L, `finally`: => Unit = ())
                         (block: => R): L \/ R = {

    try {
        \/-(block)
    } catch {
        case NonFatal(e) => -\/(exceptionContainer(e))
    } finally {
       `finally`
    }
}

例如只返回一个R，最后只是() 而不是() => ()，不需要类型欺骗。如果您甚至愿意解除 finally 块，您可以这样做：

def catchMe[L,R](exceptionContainer: Throwable => L)(block: =>  R) : L \/ R = {
   Try {block}.toDisjunction.leftMap(exceptionContainer)
}

如果您希望您的解决方案正常工作，您将需要此函数签名：

def tryCatchIn[L, R, L2 >: L](exceptionContainer: Throwable => L2, `finally`: => Unit = () => ())
                         (block: => L \/ R): L2 \/ R 

因为\/ 被定义为\/[+A,+B]。使用L2 :> L 技巧是解决方案，但您还需要使用正确的返回类型。