在编译时（Scala）中使用可变参数时是否可以控制函数中参数的数量？

Question

假设，我们必须创建仅包含奇数个元素的OddList[+T] 。 现在我们可以做这样的事情吗

OddList(1,2) //Works fine
OddList(1,2,3) //Compilation error

如果没有奇数/偶数的条件，那么我们只需执行以下操作

object OddList{
 def apply[T](eles: T*) = ...
}

但是我们可以控制可以传递的参数数量吗？

Answer 1

我不知道使用某种内置机制来限制这种情况的任何方式。 宏可能是一种可能的解决方案。 如果您想保持简单，我唯一能想到的就是要求配对：

object OddList {
 def apply[T](elems: (T, T)*) = ???
}

我还认为在命名方面可能会有些混淆，因为奇数是2n+1 ，偶数是2n （因为你可以将它们平均分成两份——参见Wikipedia ）。 因此，您可以定义以下内容：

object EvenList {
 def apply[T](elems: (T, T)*) = ???
}

object OddList {
 def apply[T](elem: T, elems: (T, T)*) = ???
}

可能不是最优雅的解决方案，但绝对简单且易于实施。

如果这种方法适合您，您可以创建非常灵活的智能构造函数，如下所示：

object Even {
  def apply[CC[_], A](
      elems: (A, A)*
  )(implicit factory: collection.Factory[A, CC[A]]): CC[A] = {
    val builder = factory.newBuilder
    for ((first, second) <- elems) {
      builder += first
      builder += second
    }
    builder.result()
  }
}

object Odd {
  def apply[CC[_], A](elem: A, elems: (A, A)*)(implicit
      factory: collection.Factory[A, CC[A]]
  ): CC[A] = {
    val builder = factory.newBuilder
    builder += elem
    for ((first, second) <- elems) {
      builder += first
      builder += second
    }
    builder.result()
  }
}

assert(Even[Set, Int]((1, 2), (3, 4)) == Set(1, 2, 3, 4))
assert(Odd[List, String]("1", ("2", "3")) == List("1", "2", "3"))

您可以在 Scastie 上使用此代码。

作为进一步的改进，我相信您还可以创建类型来包装两个可能的返回项，以便您可以在编译时推断集合大小奇偶校验（如果这是必需的），但这不在本示例中。

Answer 2

首先提出一个问题：您是否将Nil作为一个元素包括在内？

因为(1 :: 2 :: Nil).size是2 /even，你的另一个例子是3 /odd

在compile time ， shapeless具有Sized （请参阅此答案： Scala，forced length of Array/Collection parameter ），但这似乎是针对静态的、具体的值。

在运行时，您可以在调用构造函数时抛出IllegalArgumentException

    case class OddList[T]( elements: T* ) {
        private val numElements: Int = elements.size
        private val hasOddNumElements: Boolean = numElements % 2 != 0
        require(hasOddNumElements, s"There are an even [$numElements] number of elements!")
    }

    OddList( 1, 2 ) // Runtime exception
    OddList( 1, 2, 3 ) // Works fine

Answer 3

感谢@Dylan 和所有要求探索宏方式的人。 我不知道是否有更好的方法，我很想知道，但宏方法对我有用，至少现在是这样。 我尝试了下面的代码并且它有效。

trait OddArgHolder[T]{
  val args: Seq[T]
}
case class OddArgs[T](args: Seq[T]) extends OddArgHolder[T]

object OddArgHolder{
  import scala.language.experimental.macros
  import scala.reflect.macros.whitebox.Context

  def applyMacro[T](c: Context)(method: c.Expr[T]*): c.Expr[OddArgHolder[T]] = {
    import c.universe._

    if(method.size % 2 == 0){
      c.abort(c.enclosingPosition, "Only odd number of arguments allowed")
    } else {
      val met = method.map(m => c.typecheck(m.tree))
      c.Expr(c.parse(s"OddArgs( $met )"))
    }

  }

  def apply[T](method: T*): OddArgHolder[T] = macro applyMacro[T]

}


  println(OddArgHolder(1,2))
 //Compiletime output: 
 //Only odd number of arguments allowed
 //  println(OddArgHolder(1,2))