7

Is it possible to use the magnet pattern with varargs:

object Values {
  implicit def fromInt (x : Int ) = Values()
  implicit def fromInts(xs: Int*) = Values()
}
case class Values()

object Foo {  
  def bar(values: Values) {}
}

Foo.bar(0)
Foo.bar(1,2,3) // ! "error: too many arguments for method bar: (values: Values)Unit"

?

4

4 回答 4

3

正如 gourlaysama 已经提到的，将 varargs 变成一个单一的Product就可以了，从语法上讲：

implicit def fromInts(t: Product) = Values()

这允许以下调用编译良好：

Foo.bar(1,2,3)

这是因为编译器自动将 3 个参数提升为Tuple3[Int, Int, Int]. 这将适用于最多 22 个参数的任意数量的参数。现在的问题是如何使其类型安全。因为这是Product.productIterator在方法体中取回参数列表的唯一方法，但它返回一个Iterator[Any]. 我们不保证该方法将仅使用Ints 调用。这应该不足为奇，因为我们实际上甚至从未在签名中提到我们只想要Ints。

Product好的，所以无约束和可变参数列表之间的主要区别在于，在后一种情况下，每个元素都属于同一类型。我们可以使用类型类对其进行编码：

abstract sealed class IsVarArgsOf[P, E]
object IsVarArgsOf {
  implicit def Tuple2[E]: IsVarArgsOf[(E, E), E] = null
  implicit def Tuple3[E]: IsVarArgsOf[(E, E, E), E] = null
  implicit def Tuple4[E]: IsVarArgsOf[(E, E, E, E), E] = null
  implicit def Tuple5[E]: IsVarArgsOf[(E, E, E, E, E), E] = null
  implicit def Tuple6[E]: IsVarArgsOf[(E, E, E, E, E), E] = null
  // ... and so on... yes this is verbose, but can be done once for all
}

implicit class RichProduct[P]( val product: P )  {
  def args[E]( implicit evidence: P IsVarArgsOf E ): Iterator[E] = {
    // NOTE: by construction, those casts are safe and cannot fail
    product.asInstanceOf[Product].productIterator.asInstanceOf[Iterator[E]]
  }
}

case class Values( xs: Seq[Int] )
object Values {
  implicit def fromInt( x : Int ) = Values( Seq( x ) )
  implicit def fromInts[P]( xs: P )( implicit evidence: P IsVarArgsOf Int ) = Values( xs.args.toSeq )
}


object Foo {  
  def bar(values: Values) {}
}

Foo.bar(0)
Foo.bar(1,2,3)

我们更改了方法签名形式

implicit def fromInts(t: Product)

至：

implicit def fromInts[P]( xs: P )( implicit evidence: P IsVarArgsOf Int )

在方法体内，我们使用新的方法args来获取我们的 arg 列表。

请注意，如果我们尝试bar使用不是Ints 的元组的元组进行调用，我们将得到一个编译错误，这使我们恢复了类型安全。

更新：正如 0__ 所指出的，我的上述解决方案不能很好地与数字扩展配合使用。换句话说，以下内容无法编译，尽管如果bar仅采用 3 个Int参数就可以：

Foo.bar(1:Short,2:Short,3:Short)
Foo.bar(1:Short,2:Byte,3:Int)

为了解决这个问题，我们需要做的就是修改IsVarArgsOf所有的隐式允许元组元素可以转换为一个公共类型，而不是所有的都是相同的类型：

abstract sealed class IsVarArgsOf[P, E]
object IsVarArgsOf {
  implicit def Tuple2[E,X1<%E,X2<%E]: IsVarArgsOf[(X1, X2), E] = null
  implicit def Tuple3[E,X1<%E,X2<%E,X3<%E]: IsVarArgsOf[(X1, X2, X3), E] = null
  implicit def Tuple4[E,X1<%E,X2<%E,X3<%E,X4<%E]: IsVarArgsOf[(X1, X2, X3, X4), E] = null
  // ... and so on ...
}

好吧，其实我撒谎了，我们还没有完成。因为我们现在接受不同类型的元素（只要它们可以转换为通用类型，我们就不能将它们转换为预期的类型（这会导致运行时转换错误），而是必须应用隐式转换。我们可以像这样重做它：

abstract sealed class IsVarArgsOf[P, E] {
  def args( p: P ): Iterator[E]
}; object IsVarArgsOf {
  implicit def Tuple2[E,X1<%E,X2<%E] = new IsVarArgsOf[(X1, X2), E]{
    def args( p: (X1, X2) ) = Iterator[E](p._1, p._2)
  }
  implicit def Tuple3[E,X1<%E,X2<%E,X3<%E] = new IsVarArgsOf[(X1, X2, X3), E]{
    def args( p: (X1, X2, X3) ) = Iterator[E](p._1, p._2, p._3)
  }
  implicit def Tuple4[E,X1<%E,X2<%E,X3<%E,X4<%E] = new IsVarArgsOf[(X1, X2, X3, X4), E]{
    def args( p: (X1, X2, X3, X4) ) = Iterator[E](p._1, p._2, p._3, p._4)
  }
  // ... and so on ...
}
implicit class RichProduct[P]( val product: P ) {
  def args[E]( implicit isVarArg: P IsVarArgsOf E ): Iterator[E] = {
    isVarArg.args( product )
  }
}

这解决了数值扩大的​​问题，当混合不相关的类型时我们仍然得到编译：

scala> Foo.bar(1,2,"three")
<console>:22: error: too many arguments for method bar: (values: Values)Unit
          Foo.bar(1,2,"three")
                 ^
于 2013-06-02T18:48:06.003 回答
1

编辑：

永远不会选择 var-args 隐式，因为重复的参数在类型方面并不是真正的一等公民......它们仅在检查方法对参数的适用性时才存在。

所以基本上，当你调用Foo.bar(1,2,3)它时检查是否bar定义了可变参数，因为它不是，它不适用于参数。它不能再进一步了：

如果您使用单个参数调用它，它会寻找从参数类型到预期类型的​​隐式转换，但是由于您使用多个参数调用，所以存在数量问题，它无法转换多个参数到具有隐式类型转换的单个。

但是：有一个使用自动元组的解决方案。

Foo.bar(1,2,3)

编译器可以理解为

Foo.bar((1,2,3))

这意味着像这样的隐式可以工作：

implicit def fromInts[T <: Product](t: T) = Values()
// or simply
implicit def fromInts(t: Product) = Values()

这样做的问题是获取参数的唯一方法是 via t.productIterator，它返回 aIterator[Any]并且需要强制转换。

所以你会失去类型安全；这将编译（并在使用它时在运行时失败）：

Foo.bar("1", "2", "3")

我们可以使用 Scala 2.10 的隐式宏使其完全类型安全。宏只会检查参数是否确实是 aTupleX[Int, Int, ...]并且只有在通过该检查时才使自己作为隐式转换可用。

为了使示例更有用，我更改Values为保留Int参数：

case class Values(xs: Seq[Int])

object Values {
  implicit def fromInt (x : Int ) = Values(Seq(x))
  implicit def fromInts[T<: Product](t: T): Values = macro Macro.fromInts_impl[T]
}

使用宏实现：

import scala.language.experimental.macros
import scala.reflect.macros.Context
object Macro {
  def fromInts_impl[T <: Product: c.WeakTypeTag](c: Context)(t: c.Expr[T]) = {
    import c.universe._

    val tpe = weakTypeOf[T];

    // abort if not a tuple
    if (!tpe.typeSymbol.fullName.startsWith("scala.Tuple"))
      c.abort(c.enclosingPosition, "Not a tuple!")

    // extract type parameters
    val TypeRef(_,_, tps) = tpe

    // abort it not a tuple of ints
    if (tps.exists(t => !(t =:= typeOf[Int])))
      c.abort(c.enclosingPosition, "Only accept tuples of Int!")

    // now, let's convert that tuple to a List[Any] and add a cast, with splice
    val param = reify(t.splice.productIterator.toList.asInstanceOf[List[Int]])

    // and return Values(param)
    c.Expr(Apply(Select(Ident(newTermName("Values")), newTermName("apply")),
      List(param.tree)))
  }
}

最后，Foo像这样定义：

object Foo {  
  def bar(values: Values) { println(values) }
}

您可以使用与重复参数完全相同的语法获得类型安全的调用：

scala> Foo.bar(1,2,3)
Values(List(1, 2, 3))

scala> Foo.bar("1","2","3")
<console>:13: error: too many arguments for method bar: (values: Values)Unit
              Foo.bar("1","2","3")
                     ^

scala> Foo.bar(1)
Values(List(1))
于 2013-06-02T16:20:01.757 回答
0

该规范仅从函数内部指定重复参数（可变参数）的类型：

方法中这种重复参数的类型就是序列类型 scala.Seq[T]。

它不涵盖其他任何地方的类型。

所以我假设编译器内部 - 在某个阶段 - 无法匹配类型。

从这个观察（这不编译=>“双重定义”）：

object Values {
  implicit def fromInt(x: Int) = Values()
  implicit def fromInts(xs: Int*) = Values()
  implicit def fromInts(xs: Seq[Int]) = Values()
}

它似乎是 Seq []。所以接下来的尝试是让它与众不同：

object Values {
  implicit def fromInt(x: Int) = Values()
  implicit def fromInts(xs: Int*) = Values()
  implicit def fromInts(xs: Seq[Int])(implicit d: DummyImplicit) = Values()
}

这可以编译，但这并不能解决真正的问题。

我发现的唯一解决方法是将可变参数显式转换为序列：

def varargs(xs: Int*) = xs // return type is Seq[Int]

Foo.bar(varargs(1, 2, 3))

但这当然不是我们想要的。

可能相关：隐式转换函数只有一个参数。但是从逻辑（或编译器的临时）的角度来看，在可变参数的情况下，它也可以是多个。

至于类型，这可能很有趣

于 2013-06-02T14:26:24.060 回答
0

这是一个使用重载的解决方案（我不希望这样做）

object Values {
  implicit def fromInt (x :     Int ) = Values()
  implicit def fromInts(xs: Seq[Int]) = Values()
}
case class Values()

object Foo {  
  def bar(values: Values) { println("ok") }
  def bar[A](values: A*)(implicit asSeq: Seq[A] => Values) { bar(values: Values) }
}

Foo.bar(0)
Foo.bar(1,2,3)
于 2013-06-02T17:15:19.807 回答