स्कैला जेनेरिक प्रकार से कैसे मिलान करें?

Question

क्या फ़ंक्शन में पारित सामान्य प्रकार से मेल खाने का कोई तरीका है? मैं क्या करना चाहते हैं:

def getValue[T](cursor: Cursor, columnName: String): T = { 
    val index = cursor.getColumnIndex(columnName) 
    T match { 
     case String => cursor.getString(index) 
     case Int => cursor.getInteger(index) 
} 

मैं classOf या typeOf की तरह कुछ के बारे में सोचा है, लेकिन उनमें से कोई भी बस प्रकार है, लेकिन वस्तुओं के लिए स्वीकार्य है।

मेरा विचार T प्रकार का कुछ ऑब्जेक्ट बनाने के लिए भी था और फिर इसके प्रकार की जांच करें, लेकिन मुझे लगता है कि एक बेहतर समाधान हो सकता है।

Answer 1

आप ClassTag का उपयोग कर सकते हैं।

val string = implicitly[ClassTag[String]] 
def getValue[T : ClassTag] = 
    implicitly[ClassTag[T]] match { 
    case `string` => "String" 
    case ClassTag.Int => "Int" 
    case _ => "Other" 
    } 

या TypeTag:

import scala.reflect.runtime.universe.{TypeTag, typeOf} 

def getValue[T : TypeTag] = 
    if (typeOf[T] =:= typeOf[String]) 
    "String" 
    else if (typeOf[T] =:= typeOf[Int]) 
    "Int" 
    else 
    "Other" 

उपयोग:

scala> getValue[String] 
res0: String = String 

scala> getValue[Int] 
res1: String = Int 

scala> getValue[Long] 
res2: String = Other 

आप 2.9.x उपयोग कर रहे हैं आप Manifest उपयोग करना चाहिए:

import scala.reflect.Manifest 
def getValue[T : Manifest] = 
    if (manifest[T] == manifest[String]) 
    "String" 
    else if (manifest[T] == manifest[Int]) 
    "Int" 
    else 
    "Other"