Scala 中的嵌套与扁平化模式匹配

Question

假设我在 Scala 中有 n 个值 v₁, v₂, ..., v_i, .. ., v_n 类型 T_ij 是不同的 i 不一定是不同的类型。我想使用自定义逻辑对 n 值进行模式匹配。

一种方法是嵌套所有可能性，以防万一我需要详尽无遗（为了这个例子，我需要这样做，否则我可以使用占位符 mag_c）并且我不能合并分支（为了这个例子我不能，因为每个自定义逻辑都是唯一的）：

v1 match {
  case x1: T11 => v2 match {
    case x2: T21 => v3 match {
      ...
        case xn_1: Tn_11 => vn match {
          case xn: Tn1 => // Custom logic 1.
          case xn: Tn2 => // Custom logic 2.
          ...
          case xn: Tnk => // I am already laughing, but I have to write it down: 
                          // Custom logic k.
        }
        ...     
      ...
    }
    case x2: T22 => v3 match {
      // I guess you get the point. 
    }
    ...
  case x1: T12 => v2 match {
    // And so on until exhaustion in every meaning of the word.
  }
  ... // These three dots are needed here. Now I feel whole.      
}

另一种选择是将整个该死的东西弄平：

(v1, v2, ..., vn) match {
    case (x1: T11, x2: T21, ... xn: Tn1) => // Custom logic 1.
    case (x1: T11, x2: T21, ... xn: Tn2) => // Custom logic 1.
    ...
    case (x1: T11, x2: T21, ... xn: Tnk) => // Custom logic k (with a hearthy chuckle).
    ... // Three dots saving my soul and my finger joints.
}

虽然嵌套版本避免了重复输入，但当 n 很高（而我们不是）时，它会由于缩进溢出而导致难以阅读的代码。

另一方面，扁平化版本包含大量重复代码，但更易于理解。

此外，嵌套版本似乎更高效，因为 x_i 的检查每个类型最多发生一次 T_ij（但也许我不应该关心这些事情，因为 JVM 可以完全优化它，我不想成为 all evil).

哪一个是惯用的 Scala 代码，因此值得推荐？两个版本之间有性能差异吗？

Answer 1

您应该选择最能表达代码含义的选项，而不用担心性能问题。如果此 match 的性能对您的代码至关重要，那么您的设计就会遇到更大的问题。（也不清楚一个比另一个表现更好，因此根据假设的表现进行选择是不明智的）。

如果说每一个case都引出一段独立的代码，那么有一个扁平的match就是最直接的逻辑表达。添加虚假嵌套只会让事情变得混乱。

如果两个或多个case表达式之间有一些公共代码，则可以将它们分组为嵌套的match语句，这样公共代码就不会重复。如果您想在代码中表达的多个案例之间存在某种逻辑共性，这也可能适用。

另请注意，您可以使用 orElse 链接部分函数，这允许您将一个大 match 拆分为具有有意义名称的单独函数，同时避免嵌套 match 语句。

Scala 中的嵌套与扁平化模式匹配

Nested vs flattened pattern match in Scala

scala

nested

pattern-matching

flatten