Scala optionally supply named default parameter - scala

Question

Assume that we have a class constructor that takes parameters that have default value.
class A(val p1 : Int = 3, val p2 : Int = 4)
Let's say I don't have control over this class and can't modify it in anyway. What I want to do is to call A's constructor with p1 = 5, p2 = (if condition1 == true then 5 else default value). One way to do this is
if(condition1)
x = new A(5,5)
else
x = new A(5)
As you can see, this can easily get big if there are many parameters and each must be supplied conditionally. What I want is something like
x = new A(p1 = 5, p2 = <if condition1 = true then 5 else default>)
How can I do that? Note that the fields in class A are vals, so I cant change them after instantiating A.

Answer 1

It seems to me you have three possibilities:
Create variables to hold each of the values you want to specify, do all the code to fill in the values, and instantiate A once at the end. This requires knowing the default values, as Ionut mentioned. I don't think creating a throwaway object to read the defaults is all that hackish -- certainly not as much as embedding the defaults themseves -- but whatever.
Use the reflection API to create A. I'm not exactly sure how to do that but almost certainly you can pass in a list of parameters, with any unspecified parameters defaulted. This requires Scala 2.10; before that, only the Java reflection API was available and you'd have to hack through the internal implementation of optional parameters, which is hackish.
Use macros. Also 2.10+. I think that quasiquotes should make it possible to do this without too much difficulty, although I'm not too familiar with them so I can't say for sure.

Answer 2

Fetch the default values,
val defaultA = new A()
Then
val x = new A(p1 = 5, p2 = if (cond) 5 else defaultA.p2)

Answer 3

Here's the quick and sort of wrong answer:
x = new A(p1 = 5, if (condition1) 5 else A.$lessinit$greater$default$2)
The "wrong" part is that this works in 2.10 but not in 2.9. The magick name for the default method has changed from version to version (notably, between 2.9 and 2.10), so it's safer to look up its name and call it via reflection. See Instantiating a case class with default args via reflection, How do I access default parameter values via Scala reflection? and Scala dynamic instantiation with default arguments.

Answer 4

What about having a derived class from A like this:
class D(val t2: (Boolean, Int)) extends A {
override val p2: Int = if(t2._1) t2._2 else A.init$default$2
}
Now you can instantiate A like this:
x = new D((condition1, 5))
If you have more parameters, then you can add a similar override statement and tuple parameter for each.

Answer 5

I can't help feeling what you are asking for is a bit unreasonable. As stated already it should be possible with macros. But generally if you are not satisfied with the provided constructor / factory, then you have to write you're own wrapper / factory. Personally I think that we may want to look a fresh at the whole issue of default values, Null objects and the Option class. However it is possible to cut out boilerplate, without macros. Put a an implicit Boolean in your utility package:
implicit class BooleanRich2(n : Boolean) {
def apply[T](v1: T, v2: T): T = if (n) v1 else v2
}
Then say we wish to use the following class that we can't modify:
final class A(val p1: Int = 1, val p2: Int = 2, val p3: Int = 3, val p4: Int = 4){
override def toString = s"p1: $p1, p2: $p2, p3: $p3, p4: $p4"
}
We can use it as follows:
var c1 = true
var c2 = false
def c3(s: String) = (s =="")
val a = new A(c1(20, 1)) //p1: 20, p2: 2, p3: 3, p4: 4
println(a) //p1: 20, p2: 2, p3: 3, p4: 4
val b = new A(p3 = c2(20, 3), p4 = c3("")(20, 4))
println(b) //p1: 1, p2: 2, p3: 3, p4: 20
val c = new A(p3 = c1(20, 3), p4 = c3("A non empty String")(20, 4))
println(c) //p1: 1, p2: 2, p3: 20, p4: 4