爲什麼Scala隱式轉換工作有兩個參數，但沒有一個？

Question

在對象ValueSet上，我有apply(pairs : (String, ValueBase)*)以及從Int和String到ValueBase的隱式轉換。如果我申請ValueSet("a" -> 1, "b" -> 2)那麼(String, Int)對轉換爲(String, ValueBase)，它工作正常。如果我只申請一對，ValueSet("a" -> 1)則表示沒有申請(String,Int)的超載，即它不會隱式轉換。我可以通過添加apply[V <% ValueBase](p : (String, V))來解決這個問題，它可以在一對情況下工作。

爲什麼apply(pairs : (String, ValueBase)*)只能用一對？

（獎金的問題：增加額外的應用（）似乎解決的問題 - 有沒有更好的解決辦法是有什麼問題該解決方案？）

下面是一個完整編譯的例子，從我的實際代碼簡化試圖展示最小的問題。

class ValueBase 

case class ValueInt(val value : Int) extends ValueBase 
case class ValueString(val value : String) extends ValueBase 

case class ValuePair(val key : String, val value : ValueBase) 
case class ValueSet(val value : List[ValuePair]) extends ValueBase 

object ValueSet { 
    def apply(pairs : (String, ValueBase)*) : ValueSet = { 
     ValueSet(pairs.map(p => ValuePair(p._1, p._2)).toList) 
    } 

    /* Commenting out this apply() means single-pair 
    *  ValueSet("a" -> 1) 
    * will not compile, error is: 
    *  overloaded method value apply with alternatives: (value: List[ValuePair])ValueSet <and> (pairs: (String, ValueBase)*)ValueSet cannot be applied to ((java.lang.String, Int)) 
    * Why does (String,Int) implicit convert to (String,ValueBase) if there are two args but not if there's one? 
    * Why do I need this apply()? 
    */ 
    def apply[V <% ValueBase](p : (String, V)) : ValueSet = { 
     ValueSet(List(ValuePair(p._1, p._2))) 
    } 
} 

object Sample { 
    implicit def int2value(i : Int) = ValueInt(i) 
    implicit def string2value(s : String) = ValueString(s) 

    /* These samples show the goal, to construct the sets 
    * in a nice Map-literal sort of style 
    */ 
    val oneInt = ValueSet("a" -> 1) 
    val oneString = ValueSet("b" -> "c") 
    val twoInt = ValueSet("d" -> 2, "e" -> 3) 
    val twoTypes = ValueSet("f" -> 4, "g" -> "quick brown fox") 

    /* Taking ArrowAssoc out of the picture and typing "Pair" 
    * explicitly doesn't seem to matter 
    */ 
    val oneInt2 = ValueSet(Pair("a", 1)) 
    val twoTypes2 = ValueSet(Pair("f", 4), Pair("g", "quick brown fox")) 
} 

Answer 1

出現這種情況，由丹尼爾·索布拉爾在評論解釋說，因爲「編譯器看到一個說法，兩名申請這可能需要一個參數的方法，並且參數傳遞配合都不是。然後放棄考慮其他任何事情，因爲它不知道要嘗試哪種方法。如果傳遞了兩個參數，則丟棄一個應用並且編譯器查找使另一個工作的隱式轉換。「

（請記住，編譯器會自動定義一個apply，因爲您正在定義case class。 ）

如果你寫這個代替，隱式轉換工作：

object ValueSet { 
    def fromPairs(pairs: (String, ValueBase)*): ValueSet = { 
    ValueSet(pairs.map(p => ValuePair(p._1, p._2)).toList) 
    } 
} 

object Sample { 
    implicit def int2value(i: Int): ValueInt = ValueInt(i) 
    implicit def string2value(s: String): ValueString = ValueString(s) 

    /* These samples show the goal, to construct the sets 
    * in a nice Map-literal sort of style 
    */ 
    val oneInt = ValueSet.fromPairs("a" -> 1) 
    val oneString = ValueSet.fromPairs("b" -> "c") 
    val twoInt = ValueSet.fromPairs("d" -> 2, "e" -> 3) 
    val twoTypes = ValueSet.fromPairs("f" -> 4, "g" -> "quick brown fox") 
} 

不正是你所希望看到的，我知道...