Scala：如何通过函数对象参数实现签名不同的通用流程？

Question

我是一名 Java 程序员，正在逐步学习 Scala 编程。

我定义了一个类似于（可能惯用错误，我不知道...）的函数：

def someGenericAlgorithm(param1: String, param1: String, param3: String) = {

    val triedResult1 = someFunction(param1)
    triedResult1 match {
      case Success(result1) =>
        val triedResult2 = someOtherFunction(param2)
        triedResult2 match {
          case Success(result2) =>
            val triedPolymorphicResult = someToBeReplacedAccordingToSpecificLogicFunction(result1, result2, param3)
            triedPolymorphicResult match {
              case Success(polymorphicResult) =>
                doSomethingGeneric(polymorphicResult)                    
                ....
              case Failure(exception) =>
                ....
            }
          case Failure(exception) =>
            ....
        }
      case Failure(exception) =>
        ....
    }
  }

因此该函数接收 3 个参数，按顺序处理前两个参数，获取处理结果并将其与第三个参数一起传递给 someToBeReplacedAccordingToSpecificLogicFunction。

现在我想写一个类似的函数，因为存在前两个函数调用，错误逻辑是相同的，唯一的区别是 someToBeReplacedAccordingToSpecificLogicFunction 现在是 aReplacementLogicFunction .

如果这两个函数具有相同的签名，我想那不会有问题，但是，它们没有，aReplacementLogicFunction 有不同的参数，更具体地说，还有两个参数。你可能会说，我可以只传入 Option 参数，其中这两个 Option 在第一种情况下是 None，这样我就可以将我的两个函数对齐为具有相同的签名，因此：

def someToBeReplacedAccordingToSpecificLogicFunction(result1: Int, result2: Int, param3: String, unused1:Option[String] = None, unused2:Option[String] = None)

def aReplacementLogicFunction(result1: Int, result2: Int, param3: String, used1:Option[String], used2:Option[String])

但是，存在第三个流程，其中第一个函数的不存在的参数属于不同类型，例如 MyClass，例如：

def anotherReplacementLogicFunction(result1: Int, result2: Int, param3: String, used1: MyClass, used2: MyClass)

问题是，然后，我将如何生成这些函数以传递给一些重构的通用算法函数，该函数将接收一个函数作为参数。有没有办法定义类似的东西：

def refactoredOutCoreLogic(param1: String, param1: String, param3: String, polimorphicFunction: SignatureUnknown)

在Java中回答我自己的问题：

我在 Java 中解决这个问题的方法是定义一个 class 层次结构，类似于：

abstract class ResultKeeperRunnable implements Runnable {
    protected int param1, param2;
    void setParam1(...) {...}
    void setParam2(...) {...}
}

class SomeToBeReplacedAccordingToSpecificLogicFunctionClass extends ResultKeeperRunnable  {
    String param3;
    // ctor receiving all params omitted for brevity 
    void run() {
      // do specific Logic
    }
}

class AReplacementLogicFunctionClass extends ResultKeeperRunnable {
    String param3, param4, param5;
    // ctor receiving all params omitted for brevity 
    void run() {
      // do specific Logic
    }
}

class AnotherReplacementLogicFunctionClass extends ResultKeeperRunnable {
    String param3;
    MyClass param4, param5;
    // ctor receiving all params omitted for brevity 
    void run() {
      // do specific Logic
    }
}

最终分解出的核心逻辑方法是这样的：

void refactoredOutCoreLogic(String param1, String param2, String param3, ResultKeeperRunnable polimorphicLogic) {
    // error handling logic removed for brevity
    int result1 = someMethod(param1);
    int result2 = someOtherMethod(param2);
    polymorphicLogic.setParam1(result1);
    polymorphicLogic.setParam2(result2);
    polymorphicLogic.run()
    ...

}

Scala 解决方案是否不再是上述 Java 解决方案在语法上不同的克隆？好像应该有更优雅的解决方案。

Answer 1

你有一个函数，它接受result1、result2和一堆其他参数。

您想要一个只需要result1和result2的函数。

为此，请使用 partial application。像这样写你的可替换函数，最后用第二组括号包含通用参数：

def aReplacementLogicFunction(param3: String, used1:Option[String], used2:Option[String])(result1: Int, result2: Int)

然后像这样将部分应用的函数传递给您的常用函数：

someGenericAlgorithm(param1, param2, aReplacementLogicFunction(param3, used1, used2))

就泛型算法而言，它完全不知道额外的参数。这些都是在调用函数之前应用的。

Scala：如何通过函数对象参数实现签名不同的通用流程？

Scala: how to implement via function object parameters a generic flow where signatures differ?

java

functional-programming

scala

idioms