Why can I concatenate String and Int in Scala?

Question

I'm trying out some things in Scala, coming from Python. Since Scala is a lot more strict about keeping types consistent, I was surprised to find out that I can do the following concatenation, which would blow up in Python:

def adder(one:Any, two:String) = {one+two}

adder("word", "suffix")

res13: String = wordsuffix

But also:

val x:Int = 1

adder(x, "suffix")

res12: String = 1suffix

• So it just transforms an Int into a String w/out telling me. What is this called and what is the logic behind it?

• And what is the benefit of this? I feel it can come back to bite me, e.g. when dealing with user input to a function.

I know this is not very specific and if this is too broad, I'll gladly retract the question.

Answer 1

There is an implicit class in scala.Predef that operates on objects of any type

  implicit final class any2stringadd[A](private val self: A) extends AnyVal {
    def +(other: String): String = String.valueOf(self) + other
  }

That implements Any + String (as you have defined it in adder). As rogue-one mentioned, there is also a method for concatenating String + Any defined in StringOps. If you tried to do Any + Any it would fail because it's expecting a String as the argument.

So it just transforms an Int into a String w/out telling me

Scala is converting your Int into a String, but it's not a type conversion because Int cannot be coerced into a String. You can observe that by trying something like this:

def foo(str: String) = ???
foo(5)  // Type mismatch: expected: String, actual: Int

That will fail to compile because Scala can't magically coerce an Int into a String.

what is the logic behind it?

See implicit classes

And what is the benefit of this? I feel it can come back to bite me, e.g. when dealing with user input to a function.

It's a convenience method that's very specific to String and concatenation. This feature is implemented in Java, so I believe it was implemented in Scala to maintain source compatibility. My example above shows that (except in this specific case), user input to a function will respect the types defined on the function.