在scala中检索模式匹配中的类型参数答案

【问题标题】：Retrieve type parameter in pattern matching in scala在scala中检索模式匹配中的类型参数
【发布时间】：2013-12-18 05:01:50
【问题描述】：

我已经发现可以bind the type parameter进行模式匹配

为什么在这种情况下不起作用？

trait T

case class S[A](a: A) extends T

def pr(t1: T, t2: T) = (t1, t2) match {
  case (S(a): S[ta], S(b): S[tb]) => println(a); println(b)
}
                         ^
error: '=>' expected but ':' found.

有关信息，这是可行的：

def pr(t1: T, t2: T) = (t1, t2) match {
  case (s1: S[a], s2: S[b]) => println(s1.a); println(s2.a)
}

还有这个：

def pr(t1: T, t2: T) = (t1, t2) match {
  case (S(a), S(b)) => println(a); println(b)
}

我需要恢复类型以定义其他无法推断类型的函数，因为在eta-expansion的上下文中。

更新

正如 cmets 中提到的，我需要这些类型只是为了进行正确的类型检查，而不是其他任何东西。

例如：

trait T
case class S[A](a: A, w: A => Int) extends T
def makeTwo(t1: T, t2: T) = (t1, t2) match {
  case (S(a1, w1), S(a2, w2)) =>
    val wNew = { (a, b) => w1(a) + w2(b) }
    S((a, b), wNew)
}

error: missing parameter type
  val wNew = { (a, b) => w1(a) + w2(b) }
                ^

【问题讨论】：

您无法检索类型参数信息，因为它在运行时不存在 - 请参阅类型擦除
@LuigiPlinge，在这里键入擦除并不重要。作者不需要获取真正的类型，他需要绑定一个类型才能使代码通过类型检查。在编写通用 [反] 序列化库时，我也必须做类似的事情，但是，我不知何故避免了这个问题。
尝试为makeTwo 方法添加类型注释，您会发现问题所在。这个方案中的T 绝对可以是任何东西
在这种情况下，T 不是类型变量，它实际上是一个 trait。我应该把它密封吗？

标签： scala types pattern-matching

【解决方案1】：

引用 Scala 语法规则：

varid ::= lower idrest

idrest ::= {letter | digit} [‘_’ op]

op ::= opchar {opchar}

opchar ::= “all other characters in \u0020-007F and Unicode
            categories Sm, So except parentheses ([]) and periods”

// 'a' and 'a_-' is valid, 'a(' is not.

类型模式匹配规则说：

Pattern1 ::= varid ‘:’ TypePat
           | ‘_’   ‘:’ TypePat

所以

def pr(list: Any) = list match {

   case a :String => // works
   case a_- :String => // works a_- is valid instance of 'varid'
   case a() :String => // does not work.
   case a(b) :List[Int] // does not work either!
}

因此：

case S(a): S[ta]  is not valid syntax for pattern match.

但以下是有效的

case (s1 :S[a], s2: S[b])

根据元组模式匹配规则：

SimplePattern ::= ‘(’ [Patterns] ‘)’
Patterns ::= Pattern {‘,’ Patterns}

除了您列出的两个可能的选项外，您还可以使用：

 case tup: (S[_], S[_]) =>

以下似乎可行：

trait T

case class S[A](a: A, w: A => Int) extends T

def makeTwo(t1: T, t2: T) = (t1, t2) match {
  case (S(a1, w1), S(a2, w2)) =>
      val wNew = {  tup:(Any, Any) => w1(tup._1) + w2(tup._2) }
      S((a1, a2), wNew)
}

def someString (s: String) = { s.length }

val twoS = makeTwo(S("Hello", someString), S("World!", someString))
println(twoS.w(twoS.a))  // gives 11

【讨论】：

":11: 警告：类型模式 (S[ta], S[tb]) 中的非变量类型参数 S[ta] 未选中，因为它已被擦除大小写 tup 消除: (S[ta], S[tb]) =>" 当我继续时：:12: 错误：缺少扩展函数的参数类型匿名函数的参数类型必须是完全已知的。 (SLS 8.5) 预期类型为：？ val wNew = {case (a: ta, b: tb) => tup._1.w(a) + tup._2.w(b) }
@MikaëlMayer 查看更新版本，其中 wNew 定义为采用 (Any, Any) 的参数

【解决方案2】：

至少在某些情况下你可以得到你想要的。

如果您将ClassTag 类型的上下文绑定（隐式参数的语法糖）添加到您希望由编译器强制执行的类型参数中，它将具备执行此操作所需的功能。

例如，我有一个通用的 Akka 管道，用于缓冲生产者和消费者之间的消息，我希望它是类型安全的。

类是这样定义的：

class   TimedBatchQueue[T : ClassTag](batchLimit:   Int,
                                      MaxQueueTime: FiniteDuration,
                                      receiver:     ActorRef)
extends Actor

接收函数包含一个用于缓冲传入消息的案例：

  def receive = {
    ...
    case mesg: T => /* Enqueue the message */
    case mesg    => /* Bounce the unacceptable message back to the sender encapsulated in a reject message */
  }

【讨论】：