Separate constructor per each argument in Scala

Question

I'm trying to understand the following class declaration from the source code of Apache Spark:

case class HadoopFsRelation(location: FileIndex, ...)(val sparkSession: SparkSession)

I am wondering why it has the second constructor which takes SparkSession.

I just wrote some examples to clarify some points:

class Person(firstName: String)(lastName: String)(val age: Int) {
  def tellMeAboutYourSelf() = {
   //basically I have access to all three arguments
   s"$firstName, $lastName - $age"
  }
}

object Main extends App {
//no errors are shown, though it fails during compilation:
//missing argument lis for constructor Person
val singleArg: Person = new Person("Harry")

//surprisingly no errors are shown but it also fails during compilation:
//Person does not take parameters
val twoArgsCurrying: Person = singleArg("Potter")

//no errors, and the same compilation failure
//missing argument list for constructor Person
//a pure expression does nothing in statement position; you may be omitting necessary parentheses
val harry: Person = new Person("Harry")("Potter"){100}

//finally this works
val harry: Person = new Person("Harry")("Potter")(100)
println(harry.tellMeAboutYourSelf())

}

So the question what's the point in using such construction and why it is allowed in Scala?

Answer 1

Unlike most other programming languages, which allow only one parameter list (or, in the case of Haskell, for example, even only a single parameter), Scala allows multiple parameter lists each with multiple parameters.

There are several reasons to use multiple parameter lists:

• If a parameter list has only single parameter, then the argument corresponding to this parameter can be passed in curly braces as a "block", which is especially useful in the case where this parameter is a function or partial function.
• Multiple parameter lists are Scala's approach to currying, i.e. you can leave out the last argument list and you get a partially-applied function.
• Type inference flows from left to right between parameter lists, but not within a parameter list. Therefore, separating parameter lists can help type inference and reduce the amount of required type annotations.
• Identifiers introduced in a parameter list are in scope in parameter lists to the right. This allows you to use path-dependent method types where the type of a parameter in a later parameter list depends on the value of an argument in an earlier argument list.
• Only an entire parameter list can be marked implicit. If you want some parameters to be explicit and some to be implicit, you need to separate the implicit ones out into a separate parameter list.
• Only one parameter in a parameter list can be a repeated parameter. If you want multiple repeated parameters, you need to separate them out into separate parameters lists.

This one only applies to constructors, more specifically only to primary constructors, and even more specifically only to primary constructors of case classes:

• The parameters of the first parameter list are treated "special":
  • They are automatically public vals with accessors.
  • They are used to generate a sensible default implementation of ##
  • They are used to generate a sensible default implementation of ==
  • A case class will extend ProductN[A, … Z] where A, … Z are the types of the parameters of the first parameter list.
  • There will be an automatically generated companion object of the same name, which extends FunctionN[A, … Z] and has an apply method whose sole parameter list is the same as the first parameter list of the primary constructor of the case class.

So, if you do not want any of that for one of your parameters, you need to put that parameter into a separate parameter list.

Answer 2

This is not different constructors. This is a single constructor with multiple parameter lists.

https://docs.scala-lang.org/tour/multiple-parameter-lists.html

Multiple parameter lists in a method are mostly for currying/partial application.

For a case class parameters in the first list are vals (i.e. accessible outside the class) automatically.