Arity-1
Scala has a special syntax for invoking methods of arity-1 (one argument):

names.mkString(",")
// is the same as
names mkString ","

This syntax is formally known as “infix notation”. It should only be used for purely-functional methods (methods with no side-effects) - such as mkString -or methods which take functions as parameters - such as foreach:

// right!
names foreach (n => println(n))
names mkString ","
optStr getOrElse ""
// wrong!
javaList add item

Read more: Scala documentation: Method Invocation

infix notation arity-1

The type of the repeated parameter inside the function is an Array of the declared type of the parameter. Nevertheless, if you have an array of the appropriate type, and attempt to pass it as a repeated parameter, you'll get a compiler error:

  scala> val arr = Array("What's", "up", "doc?")
  arr: Array[java.lang.String] = Array(What's, up, doc?)
  
  scala> echo(arr)
  :7: error: type mismatch;
   found   : Array[java.lang.String]
   required: String
         echo(arr)
              ^

To accomplish this, you'll need to append the array argument with a colon and an _* symbol, like this:

  scala> echo(arr: _*)
  What's
  up
  doc?

This notation tells the compiler to pass each element of arr as its own argument to echo, rather than all of it as a single argument.
Read more: Repeated parameters

parameters

Scala optimizes the tail recursive call:

def bang(x: Int): Int = 
  if (x == 0) throw new Exception("bang!")
  else bang(x - 1)

scala> bang(5)
java.lang.Exception: bang!
      at .bang(<console>:5)
      at .<init>(<console>:6)

Scala only optimizes directly recursive calls back to the same function making the call. If the recursion is indirect, no optimization is possible:

def isEven(x: Int): Boolean =
  if (x == 0) true else isOdd(x - 1)
def isOdd(x: Int): Boolean =
  if (x == 0) false else isEven(x - 1)

You also won't get a tail-call optimization if the final call goes to a function value.

val funValue = nestedFun _
def nestedFun(x: Int) { 
  if (x != 0) { println(x); funValue(x - 1) }
}

Read more: Tail recursion

functions recursion