4

显然，提取器对象中的 unapply/unapplySeq 不支持隐式参数。假设这里有一个有趣的参数 a，以及一个令人不安的无处不在的参数 b，当提取 c 时，它会很好地隐藏起来。

[编辑]：似乎我的 intellij/scala-plugin 安装中出现了一些问题，导致了这种情况。我无法解释。我的智能最近遇到了许多奇怪的问题。重新安装后，我无法再重现我的问题。确认 unapply/unapplySeq 确实允许隐式参数！谢谢你的帮助。

这不起作用（**编辑：是的，确实如此）：**

trait A; trait C; trait B { def getC(a: A): C }

def unapply(a:A)(implicit b:B):Option[C] = Option(b.getC(a))

根据我对理想提取器应该是什么样子的理解，其中意图对于 Java 人员来说也很直观，这个限制基本上禁止了依赖于附加参数的提取器对象。

您通常如何处理此限制？

到目前为止，我有这四种可能的解决方案：

1）我想改进的最简单的解决方案：不要隐藏b，提供参数b和a，作为元组形式的unapply的普通参数：

object A1{ 
    def unapply(a:(A,B)):Option[C] = Option(a._2.getC(a._1)) }

在客户端代码中：

 val c1 = (a,b) match { case A1(c) => c1 }

我不喜欢它，因为这里有更多的噪音偏离将 a 解构为 c 很重要。此外，由于必须说服 Java 人员实际使用此 scala 代码，因此面临着一种额外的语法新颖性（元组大括号）。他们可能会得到反 scala 攻击“这都是什么？......为什么不首先使用正常方法并检查是否？”。

2) 在封装了对特定 B 的依赖的类中定义提取器，导入该实例的提取器。在导入站点对于 java 人来说有点不寻常，但是在模式匹配站点 b 被很好地隐藏了，并且直观地很明显会发生什么。我最喜欢的。我错过了一些缺点？

class BDependent(b:B){ 
   object A2{ 
    def unapply(a:A):Option[C] = Option(b.getC(a))
         } }

客户端代码中的用法：

val bDeps = new BDependent(someB)
import bDeps.A2 
val a:A = ...
val c2 = a match { case A2(c) => c }
}

3) 在客户端代码范围内声明提取器对象。b 是隐藏的，因为它可以在本地范围内使用“b”。妨碍代码重用，严重污染客户端代码（此外，在代码使用之前必须说明）。

4) 具有函数 B => C 的 unapply return 选项。这允许导入和使用依赖于参数的提取器，而无需将 b 直接提供给提取器，而是在使用时提供结果。Java 人可能对函数值的使用感到困惑，b 不是隐藏的：

 object A4{
  def unapply[A,C](a:A):Option[B => C] = Option((_:B).getC(a))
   }

然后在客户端代码中：

 val b:B = ...
 val soonAC: B => C = a match { case A4(x) => x }
 val d = soonAC(b).getD ...

补充说明：

  • 正如这个答案所建议的，“视图边界”可能有助于让提取器与隐式转换一起工作，但这对隐式参数没有帮助。出于某种原因，我不喜欢使用隐式转换来解决。
  • 调查了“上下文边界”，但它们似乎有相同的限制，不是吗？
4

2 回答 2

4

你的第一行代码在什么意义上不起作用？对于提取器方法的隐式参数列表当然没有任意禁止。

考虑以下设置（我使用普通的旧类而不是案例类来表明这里没有发生额外的魔法）：

class A(val i: Int)
class C(val x: String)
class B(pre: String) { def getC(a: A) = new C(pre + a.i.toString) }

现在我们定义一个隐式B值并使用您的方法创建一个提取器对象unapply：

implicit val b = new B("prefix: ")

object D {
  def unapply(a: A)(implicit b: B): Option[C] = Option(b getC a)
}

我们可以这样使用：

scala> val D(c) = new A(42)
c: C = C@52394fb3

scala> c.x
res0: String = prefix: 42

完全符合我们的预期。我不明白为什么你需要一个解决方法。

于 2012-09-09T11:40:22.743 回答
1

您遇到的问题是隐式参数是编译时（静态）约束，而模式匹配是运行时（动态）方法。

trait A; trait C; trait B { def getC(a: A): C }

object Extractor {
  def unapply(a: A)(implicit b: B): Option[C] = Some(b.getC(a))
}

// compiles (implicit is statically provided)
def withImplicit(a: A)(implicit b: B) : Option[C] = a match { 
  case Extractor(c) => Some(c)
  case _            => None
}

// does not compile
def withoutImplicit(a: A) : Option[C] = a match { 
  case Extractor(c) => Some(c)
  case _            => None
}

所以这是一个概念问题，解决方案取决于您实际想要实现的目标。如果你想要一些类似于可选隐式的东西，你可以使用以下内容：

sealed trait FallbackNone {
  implicit object None extends Optional[Nothing] {
    def toOption = scala.None
  }
}
object Optional extends FallbackNone {
  implicit def some[A](implicit a: A) = Some(a)
  final case class Some[A](a: A) extends Optional[A] { 
    def toOption = scala.Some(a)
  }
}
sealed trait Optional[+A] { def toOption: Option[A]}

那么你拥有的地方implicit b: B将拥有implicit b: Optional[B]：

object Extractor {
   def unapply(a:A)(implicit b: Optional[B]):Option[C] = 
      b.toOption.map(_.getC(a))
}

def test(a: A)(implicit b: Optional[B]) : Option[C] = a match { 
   case Extractor(c) => Some(c)
   case _            => None
}

以下都编译：

test(new A {}) // None

{
  implicit object BImpl extends B { def getC(a: A) = new C {} }
  test(new A {}) // Some(...)
}
于 2012-09-09T11:52:19.637 回答