How to propagate default arguments between functions in Kotlin? - kotlin

Question

Kotlin has default arguments for function and constructor parameters. Now, I have a function
fun foo(bar: String = "ABC", baz: Int = 42) {}
and I want to call it from different places but also retain the possibility to not pass on of the arguments and instead use the default value.
I know, I can declare the default arguments in the calling functions
fun foo2(bar: String = "ABC", baz: Int = 42) {
// do stuff
foo(bar, baz)
}
fun foo3(bar: String = "ABC", baz: Int = 42) {
// do other stuff
foo(bar, baz)
}
but now my default parameter in foo is pointless as it's always overwriten and I have duplicated the default arguments in all calling functions. That's not very DRY.
Is there a better way to propagate the default arguments?

Answer 1

Instead of having three functions with the same default arguments:
fun foo(bar: String = "ABC", baz: Int = 42)
fun foo2(bar: String = "ABC", baz: Int = 42)
fun foo3(bar: String = "ABC", baz: Int = 42)
Create a wrapper class that takes in the arguments, and have the functions without parameters:
class Foo(val bar: String = "ABC", val baz: Int = 42) {
fun foo() { /* ... */ }
fun foo2() {
// ...
foo()
}
fun foo3() {
// ...
foo()
}
}

Answer 2

Answering my own question as encouraged by the guidelines.
What you can do, is declare the parameters in the calling functions as nullable and use null as the default argument:
fun foo2(bar: String? = null: Int? = null) {
// do stuff
foo(bar, baz)
}
fun foo3(bar: String? = null, baz: Int? = null) {
// do other stuff
foo(bar, baz)
}
Then, use one of the elvis operator to use default values, when null is provided.
fun foo(bar: String? = null, baz: Int? = null) {
val realBar = bar ?: "ABC"
val realBaz = baz ?: 42
}
If you're dealing with a class instead of a function, you can pull out the property of the constructor and assign the default value there:
class Foo(bar: String? = null, baz: Int? = null) {
val bar = bar ?: "ABC"
val baz = baz ?: 42
}
Alternatively, say if your class is a data class and you want to have the properties in the primary constructor, you can declare a factory method to handle the default values:
class Foo(val bar: String, baz: Int) {
companion object {
fun create(bar: String? = null, baz: Int? = null) = Foo(bar ?: "ABC", baz ?: 42)
}
}

Answer 3

If you have multiple functions taking the same arguments (with the same default values), then that is a code-smell suggesting that those parameters are closely related and should live inside their own class.
data class FooArgs( val bar: String = "ABC", val baz: Int = 42 )
fun foo( args: FooArgs = FooArgs() ) { /* ... */}
fun foo2( args: FooArgs = FooArgs() ) {
...
foo(args)
}
fun foo3( args: FooArgs = FooArgs() ) {
...
foo(args)
}
If foo and/or foo2, foo3 only use their arguments, then further refactoring would move foo and foo2 into the FooArgs class, resulting in a similar solution to the answer by #nhaarman