Scala: how to call method without tuple argument? - scala

Question

I have two methods to add elements to a customized collection:
class WrappedMap[A, B] {
protected var a2b = Map[A, B]()
def +=(a: A, b: B) = {
a2b += a -> b
this
}
def +=(t: (A,B)): this.type = {
this.+=(t._1, t._2)
}
def ++=(t: Iterable[(A,B)]) = {
(this /: t){ case (b, elem) => b += elem }
}
}
val c = new WrappedMap[Int, Int]
c ++= Seq((1, 2),(2, 4))
It throws a Stackoverflow exception because the call to the += inside ++= calls the +=, which in turns call itself instead of calling the first variant.
How can I change the call in the body of the second += so that it calls the first one?

Answer 1

The problem is the specification of this.type as the return type from the second form of +=. Not sure the exact reason but the compiler does not recognise the first form as returning this.type therefore it can't be used to satisfy the return type of the second form. I recreated it with:
case class Foo[A,B](s: String) {
def bar(a: String, b: String) = {
this.copy(s"a: $a b: $b")
}
def bar(c: (String, String)): this.type = {
this.bar (c._1, c._2)
}
}
val f = Foo("")
f bar (("hello", "world"))
Instead, you can just use the class and type params as the return type:
case class Foo[A, B](s: String) {
def bar(a: String, b: String) : Foo[A,B] = {
this.copy(s"a: $a b: $b")
}
def bar(c: (String, String)): Foo[A, B] = {
this.bar (c._1, c._2)
}
}
val f = Foo[Int, Long]("")
f bar (("hello", "world"))
Or, where inheritance needs to be supported:
class Foo[A, B] {
private var s: String = ""
def bar(a: String, b: String) : this.type = {
s = s"a: $a b: $b"
this
}
def bar(c: (String, String)): this.type = {
this.bar (c._1, c._2)
}
}
case object Foo2 extends Foo[Int, Long]
Foo2 bar (("hello", "world"))