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

Question

我已经发现可以在模式匹配中绑定类型参数

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

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扩展的上下文中，这些函数的类型无法推断。

更新

正如评论中所提到的，我需要的类型只是用于正确的类型检查，而不是其他任何东西。

例如：

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) }
                ^

Answer 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

Answer 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 */
  }