Scala: Constructor taking either Seq or varargs

Question

I am guessing that, for compatibility reasons, the type of vararg parameters Any* is Array[Any] - please correct this if I'm wrong. However, this does not explain the following error:

class Api(api_url: String, params: Seq[(String, String)]) {
  def this(api_url: String, params: (String, String)*)
    = this(api_url, params.seq)
}

This code does not compile, but gives the warning:

double definition: constructor Api:(api_url: String, params: (String, String)*)Api and constructor Api:(api_url: String, params: Seq[(String, String)])Api at line 13 have same type after erasure: (api_url: java.lang.String, params: Seq)Api

So how do I define a constructor taking either varargs or a sequence?

score 33 · Accepted Answer · answered Aug 12 '11 at 13:56

A method taking varargs is also always taking a sequence, so there is no need to define an auxiliary constructor or overloaded method.

Given

class Api(api_url: String, params: (String, String)*)

you can call it like this

new Api("url", ("a", "b"), ("c", "d"))

or

val seq = Seq(("a", "b"), ("c", "d"))
new Api("url", seq:_*)

Also, in your question, you are calling method seq on the params parameter. This probably does not do what you intended. seq is used to ensure that operations on the resulting collection are executed sequentially instead of in parallel. The method was introduced with the parallel collections in version 2.9.0 of Scala.

What you probably wanted to use was toSeq, which returns the collection it is used on converted to a Seq (or itself if it is already a Seq). But as varargs parameters are already typed as Seq, that is a no-op anyway.

May I point out that the type annotation `:_*` is what really makes the constructor call using the sequence argument compatible to the varargs constructor. More details: http://stackoverflow.com/questions/6051302/what-does-colon-underscore-star-do-in-scala — Johannes Rudolph, May 21 '15 at 13:21

score 10 · Answer 2 · answered Aug 12 '11 at 13:05

10

No: actually, Any* is actually almost identical to Seq[Any], not to Array[Any].

To disambiguate between the two, you can use the technique to add a dummy implicit parameter to make the signature different:

class Api(api_url: String, params: Seq[(String, String)]) {
  def this(api_url: String, params: (String, String)*)(implicit d: DummyImplicit) =
    this(api_url, params)
}

answered Aug 12 '11 at 13:05

Jean-Philippe Pellet

59,296
21
173
234

1

...isn't this ...really disgusting? – wen Aug 12 '11 at 13:09
5

Well, feel free to provide a less “disgusting” solution! – Jean-Philippe Pellet Aug 12 '11 at 13:10
When I figure one out, I will. For now, I'll just scratch the `varargs` constructor. ^^ – wen Aug 12 '11 at 13:14
4

Why not keep the varargs constructor and let the caller do the `seq:_*` thing if he wants? – Derek Wyatt Aug 12 '11 at 13:31
@Derek: because I didn't know `seq:_*` existed. :) – wen Aug 18 '11 at 00:55
1

Designing new interfaces should one prefer `vargargs` over `Seq`? – Ivan Balashov Jun 12 '16 at 08:47

score 2 · Answer 3 · answered Feb 15 '16 at 10:18

2

I suppose that you would like to make the method calls prettier and so explicit calling with _* is not an option. In that case you may solve the problem with method overloading.

class Api(api_url: String, params: Seq[(String, String)]) {
  def this(api_url: String, param : (String, String), params: (String, String)*)
    = this(api_url, param +: params)
  def this(api_url: String)
    = this(api_url, Seq())
}

answered Feb 15 '16 at 10:18

ayvango

5,867
3
34
73

This is the best solution as far as I'm concerned. It allows you to do `Api("url")`, `Api("url", "a" -> "b")`, `Api("url", Seq("a" -> "b"))` without sacrifiycing readability with the `:_*` – Eduardo Dec 10 '19 at 09:53

Scala: Constructor taking either Seq or varargs

3 Answers3

Linked