Question

我希望能够动态选择在我的case类模式匹配中使用哪些提取器。

我想要类似的东西：

def handleProcessingResult(extract: SomeType) : PartialFunction[Event, State] = {
    case Event(someEvent: SomeEvent, extract(handlers)) =>
        ...

    case Event(otherEvent: OtherEvent, extract(handlers)) =>
        ...
}

我的想法是我可以拥有上面的部分功能，然后可以在我知道如何编写unapply以匹配并从某些模式匹配类型中提取handlers的任何地方使用它。

如果您想知道我为什么需要这些部分函数，那么我可以将共同行为的部分函数组合在一起，以形成Akka FSM中状态的处理程序。这不是理解问题所必需的，但例如：

when(ProcessingState) {
    handleProcessingResult(extractHandlersFromProcessing) orElse {
        case Event(Created(path), Processing(handlers)) =>
            ...
    }
}

when(SuspendedState) {
   handleProcessingResult(extractHandlersFromSuspended) orElse {
       case Event(Created(path), Suspended(waiting, Processing(handlers))) =>
           ...
}

似乎这应该是可能的，但我无法弄清楚如何！

我尝试了以下两种简化：

object TestingUnapply {

  sealed trait Thing
  case class ThingA(a: String) extends Thing
  case class ThingB(b: String, thingA: ThingA) extends Thing

  val x = ThingA("hello")
  val y = ThingB("goodbye", ThingA("maybe"))

  process(x, new { def unapply(thing: ThingA) = ThingA.unapply(thing)})
  process(y, new { def unapply(thing: ThingB) = ThingB.unapply(thing).map(_._2.a)})


  def process(thing: Thing, extract: { def unapply[T <: Thing](thing: T): Option[String]}) = thing match {
    case extract(a) => s"The value of a is: $a"
  }
}

我的想法是，我应该能够将任何子类型的Thing和合适的提取器传递给process。但是，它由于以下原因而无法编译：

[error] /tmp/proj1/TestUnapply.scala:10: type mismatch;
[error]  found   : AnyRef{def unapply(thing: TestingUnapply.ThingA): Option[String]}
[error]  required: AnyRef{def unapply[T <: TestingUnapply.Thing](thing: T): Option[String]}
[error]   process(x, new { def unapply(thing: ThingA) = ThingA.unapply(thing)})
[error]              ^
[error] /tmp/proj1/TestUnapply.scala:11: type mismatch;
[error]  found   : AnyRef{def unapply(thing: TestingUnapply.ThingB): Option[String]}
[error]  required: AnyRef{def unapply[T <: TestingUnapply.Thing](thing: T): Option[String]}
[error]   process(y, new { def unapply(thing: ThingB) = ThingB.unapply(thing).map(_._2.a)})
[error]              ^

随后，将类型参数T的声明移到process上，给我们：

import scala.reflect.ClassTag

object TestingUnapply {

  sealed trait Thing
  case class ThingA(a: String) extends Thing
  case class ThingB(b: String, thingA: ThingA) extends Thing

  val x = ThingA("hello")
  val y = ThingB("goodbye", ThingA("maybe"))

  process(x, new { def unapply(thing: ThingA) = ThingA.unapply(thing)})
  process(y, new { def unapply(thing: ThingB) = ThingB.unapply(thing).map(_._2.a)})

  def process[T <: Thing: ClassTag](thing: Thing, extract: { def unapply(thing: T): Option[String]}) = thing match {
    case extract(a) => s"The value of a is: $a"
  }
}

现在给我们一个不同的编译错误：

[error] /tmp/TestUnapply.scala:18: Parameter type in structural refinement may not refer to an abstract type defined outside that refinement
[error]   def process[T <: Thing: ClassTag](thing: Thing, extract: { def unapply(thing: T): Option[String]}) = thing match {

我最有可能做些蠢事。有人能帮帮我吗？

Answer 1

尝试根据您的第一次简化制定解决方法，希望它有所帮助。

 object DynamicPattern extends App {

    sealed trait Thing
    case class ThingA(a: String) extends Thing
    case class ThingB(b: String, thingA: ThingA) extends Thing

   // change structural type to an abstract class
   abstract class UniversalExtractor[T <: Thing] {
     def unapply(thing: T): Option[String]
   }

   // extract is an instance of UniversalExtractor with unapply method
   // naturally it's an extractor
   def process[T <: Thing](thing: T, extract: UniversalExtractor[T]) = 
     thing match {
       case extract(a) => s"The value of a is: $a"
     }

   val x = ThingA("hello")
   val y = ThingB("goodbye", ThingA("maybe"))

   val result1 = process(
     x,
     new UniversalExtractor[ThingA] {
        def unapply(thing: ThingA) = ThingA.unapply(thing)
     }
   )

   val result2 = process(y,
     new UniversalExtractor[ThingB] {
        def unapply(thing: ThingB) =   ThingB.unapply(thing).map(_._2.a)
     }
   )

   // result1 The value of a is: hello
   println(" result1 " + result1)
   // result2 The value of a is: maybe
   println(" result2 " + result2)
}

更新

一种可能“讨厌”的方法，不使用我后面解释的类型一致性问题暗示的抽象类或特征。

  // when invoking process method, we actually know which subtype of 
  // Thing is pattern-matched, plus the type conformance problem, 
  // so here comes the ```unapply[T <: Thing](thing: T)``` 
  // and ```asInstanceOf(which is usually not that appealing)```. 
  val thingAExtractor = new { 
    def unapply[T <: Thing](thing: T): Option[String] = 
      ThingA.unapply(thing.asInstanceOf[ThingA])
  }

  val thingBExtractor = new {
    def unapply[T <: Thing](thing: T): Option[String] =
      ThingB.unapply(thing.asInstanceOf[ThingB]).map(_._2.a)
  }

  // hello
  println(process(x, thingAExtractor))
  // maybe
  println(process(y, thingBExtractor))

它在两个简化中不起作用的原因（实际上，当我试图找出原因时，在我的脑海中突然出现了令人讨厌的方法，所以只要在这里写它就会有帮助）。

对于第一个简单：它是关于 type conformance 问题。

  type ExtractType = { def unapply[T <: Thing](thing: T): Option[String] }
  val anonExtractor = new { def unapply(thing: ThingA) = ThingA.unapply(thing) }

  import scala.reflect.runtime.{ universe => ru }
  import scala.reflect.runtime.universe.{ TypeTag, typeTag }
  def getTypeTag[T: TypeTag](o: T) = typeTag[T].tpe
  def getTypeTag[T: TypeTag] = ru.typeOf[T]

  // false | so in turn type check fails at compilation time
  println(getTypeTag(anonExtractor) <:< getTypeTag[ExtractType])

ScalaDoc Reflection的 Java中的运行时类与Scala中的运行时类型部分演示了类似情况下的类型一致性。简而言之，Scala编译器创建在运行时使用的合成类代替用户定义的类，在该部分中提到的情况下将其转换为等效的Java字节码。

对于第二个简化：这篇文章parameter-type-in-structural-refinement-may-not-refer-to-an-abstract-type-define-outside给出了一些详细的解释。

动态传递提取器以进行模式匹配

1 个答案: