Scalaは：私は<code>scala implicit</code>に関連する初心者の質問があり、パラメータ型

Question

に基づいて値を設定します。

class Box[T](implicit tag: ClassTag[T]) { 
    var value = None: Option[Any] 

    def pickValueUsingTypeOfT : Unit = { 
    val list = List("string", 1, new myClass(1D)) 
    println(s"type of has type arguments $tag") 
    //value = Some (find right element from the 'list') 
    } 
} 

class myClass(double: Double) {} 


object Setter { 

    def main(args: Array[String]) { 
    val n: Box[String] = new Box[String] 
    n.pickValueUsingTypeOfT 
    } 
} 

目的はTの種類に応じてvalueを設定することです。

Answer 1

このような解像度にはリフレクションは必要ありません。 のようにtypeclassが必要です。

trait Foo[T] { 
    def aProp: String 
    def aFun(v: T): Int 
} 

object Foo { 
    // default instances 

    object StrFoo extends Foo[String] { 
    // for T = String 
    val aProp = "Bar" 
    def aFun(v: String) = v.length 
    } 

    object LongFoo extends Foo[Long] { 
    val aProp = "Lorem" 
    def aFun(v: Long) = v.toInt 
    } 
} 

あなたの関数は次のように定義できます。

def pickValueUsingTypeOfT[T](implicit resolved: Foo[T]) = ??? 

そして、それは、デフォルトのインスタンスのために使用することができます。

pickValueUsingTypeOfT[String].aProp 
pickValueUsingTypeOfT[Long].aFun(123L) 

それがサポートされていないタイプのために呼ばれていた場合、コンパイラは（ランタイムリフレクションよりもその優れた）この問題を見つけて、あなたを助ける：

pickValueUsingTypeOfT[Byte] // compiler error 

余分のインスタンスを定義できます。

val localV = "value" 

implicit val byteFoo: Foo[Byte] = new Foo[Byte] { 
    def aProp: String = localV 
    def aFun(v: Byte) = v.toInt * 10 
} 

pickValueUsingTypeOfT[Byte].aFun(456.toByte) 
// now is ok with byteFoo