Scala：可選的類型參數？

Question

我寫了這樣的方法：

def typeOnly[T, S](seq: Seq[S]): Seq[T] = {
  seq.flatMap{
    case t: T => Some(t)
    case _ => None
  }
}

我希望以此方式調用它：

typeOnly[String](List(1, "2", 3, "4"))

沒用 我似乎必須指定第二種類型的參數S ：

typeOnly[String, Any](List(1, "2", 3, "4"))

但為什么？ 編譯器不應該知道List(1, "2", 3, "4")是Seq[Any]的事實嗎？

Answer 1

TL; DR

將其用於Scala 2.9.x：

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) : Seq[T] = { 
    seq.collect { 
        case t if m.erasure.isInstance(t) => t.asInstanceOf[T]
    }
}

scala> typeOnly[String](List(1,2,"3",4))
res1: Seq[String] = List(3)    

這對於Scala 2.10.x：

def typeOnly[T](seq : Seq[Any])(implicit tag : scala.reflect.ClassTag[T]) = { 
    seq.collect { 
        case t if tag.runtimeClass.isInstance(t) => t.asInstanceOf[T]
    }
}

---

由於Seq被定義為trait Seq[+A] （鍵為+ ），因此任何Seq[S]也是Seq[Any] 。

另一方面，正如已經說過的，在編譯函數時T被“遺忘”，因此您不能直接使用它。 您必須以某種方式傳遞T類作為參數。

def typeOnly[T](seq : Seq[Any], c : Class[T]) : Seq[T] = { 
    seq.flatMap { 
        case t if c.isInstance(t) => Some(t.asInstanceOf[T])
        case _ => None 
    }
} 

在Scala中，來自Class[T] appart中也有Manifest[T] ，它功能更強大，因此更加慣用。 特別是，它具有方法erasure ，該方法erasure返回Class[T] 。 使用它，您可以像這樣編寫函數：

def typeOnly[T](seq : Seq[Any], m : Manifest[T]) : Seq[T] = { 
    seq.flatMap { 
        case t if m.erasure.isInstance(t) => Some(t.asInstanceOf[T])
        case _ => None 
    }
} 

看來我們一無所獲。 但是，如果您很好地要求編譯器（使用implicit ），則在調用函數時它將為您傳遞Manifest 。

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) : Seq[T] = { 
    seq.flatMap { 
        case t if m.erasure.isInstance(t) => Some(t.asInstanceOf[T])
        case _ => None 
    }
}

例子：

scala> typeOnly[java.lang.Integer](List(1,2,"3",4))
res2: Seq[java.lang.Integer] = List(1, 2, 4)

scala> typeOnly[String](List(1,2,"3",4))
res3: Seq[String] = List(3)

scala> typeOnly[java.lang.Double](List(1,2,"3",4))
res4: Seq[java.lang.Double] = List()

還有更多選擇，其中有些更慣用。 例如，您可以將collect與部分定義的函數一起使用：

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) : Seq[T] = { 
    seq.collect { 
        case t if m.erasure.isInstance(t) => t.asInstanceOf[T]
    }
}

警告 ：以前的示例在Scala 2.9.3及更低版本中有效。 如果您正在為Scala 2.10.x開發， 則不建議使用 Manifest#erasure 。 使用runtimeClass代替：

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) = { 
    seq.collect { 
        case t if m.runtimeClass.isInstance(t) => t.asInstanceOf[T]
    }
}

由於清單也會很快被棄用（請參見下面的注釋），因此您應該考慮使用ClassTag。

def typeOnly[T](seq : Seq[Any])(implicit tag : scala.reflect.ClassTag[T]) = { 
    seq.collect { 
        case t if tag.runtimeClass.isInstance(t) => t.asInstanceOf[T]
    }
}

Answer 2

您的case t: T => Some(t)不會按類型T過濾元素。 您需要的是這樣的：

  def typeOnly[T](seq: Seq[Any], clazz: Class[T] = classOf[Any]): Seq[T] = {
    seq.flatMap{
      case t: T if clazz.isInstance(t) => Some(t)
      case _ => None
    }
  }

您這樣調用：

typeOnly(Seq(1, "2", 3))
typeOnly(Seq(1, "2", 3), classOf[String])

Answer 3

如果您旨在允許typeOnly用戶僅指定T type參數，則可以通過以下方式進行定義：

def typeOnly[S](seq: Seq[S]) = new {
  def apply[T]: Seq[T] =
    seq.flatMap{
      case t: T => Some(t)
      case _ => None
    }
}

您必須這樣稱呼它

val l = typeOnly(List(1, "2", 3, "4"))[String]

（注意，在參數之后而不是typeOnly之后的type參數）。

由於它特別使用結構類型，因此增加了編譯器警告。 如果要避免添加import language.reflectiveCalls來解決此問題，則可以依賴中間類：

case class TypeOnlyFilter[S](seq: Seq[S]) {
  def apply[T]: Seq[T] =
    seq.flatMap{
      case t: T => Some(t)
      case _ => None
    }
}

def typeOnly[S](seq: Seq[S]) =
  new TypeOnlyFilter(seq)

請注意，此實現仍然具有關於未檢查的抽象類型模式T的編譯器警告（與您的原始實現一樣）。 您只需要為T類型要求ClassTag即可解決此問題，因此最終解決方案如下所示：

import scala.reflect.ClassTag

case class TypeOnlyFilter[S](seq: Seq[S]) {
  def apply[T: ClassTag]: Seq[T] =
    seq.flatMap{
      case t: T => Some(t)
      case _ => None
    }
}

def typeOnly[S](seq: Seq[S]) =
  new TypeOnlyFilter(seq)