Fluent methods for data class in kotlin

Question

We are familiar with fluent interfaces for calling methods in java and other programming languages. For eg:

Picasso.with(this).load(url).into(imageView);

This is made possible by setter methods what return object of desired type.

public Picasso with(Context context)
{
    this.context = context;
    return this;
}

public X load(String url)
{
    this.url = url;
    return this;
}

public Y load(ImageView imageView)
{
    this.imageView = imageView;
    return this;
}

I am trying to do the same with kotlin data classes but sadly I could not find a way to override the setter methods in which I could return the new instance of that object.

I get compiler error when I try to forcefully override setter method.

Any idea about what can be done so that I can call fluent interfaces or at least alter how the setter works may be like this

data class CorruptOfficeAccount(.....){
     override fun addCollectedFee(Long money) :CorruptOfficeAccount {
     this.money = money/5
    }
}

So that I can call

CorrutOfficeAccount(....).method1().addCollectedFee(20000).method3()

Answer 1

If don't need to return anything but Name, you can just do it like this instead:

data class Name(var firstName: String, var lastName: String)

fun foo() {
    val name = ...
    name.apply {
        firstName = ...
        lastName = ...
    }
}

or another example:

CorrutOfficeAccount(....).apply {
    method1()
    addCollectedFee(20000)
    method3()
}

Inside the function (what's inside the curly braces) passed to apply, this is the object apply was called on, which makes it possible to refer to member functions and properties like firstName without writing name.firstName.

If you're not happy with this: It's not possible to make the actual setter return something, however you can of course just define a method with a different name and make that return something.

Answer 2

For accessing properties in Kotlin, we don't use getter and setter functions, and while you can override their setters to give them custom behaviour, you can't make them return anything, because calling them is an assigment, which is not an expression in Kotlin. As an example, this doesn't work:

var x = 1
var y = (x = 5) // "Assigments are not expressions, and only expressions are allowed in this context"

What you can do is define additional methods that set them, and then return the instance they were called on. For example:

data class Name(var firstName: String = "", var lastName: String  =  "") {
    fun withLastName(lastName: String): Name {
        this.lastName = lastName
        return this
    }
}

val name = Name(firstName = "Jane") 
name.withLastName("Doe").withLastName("Carter")

Note that if you name this method setLastName, you'll have problems with using the class from Java, because the lastName property is already visible through a method called setLastName when you're writing Java code.

The perhaps more usual solution in Kotlin though is to replace fluent builders by using apply from the standard library, as it was already described in Christian's answer.

Answer 3

Thanks to Zsmb13 and Christin for the answer, but if someone wants to use immutable fields I have another solution

data class Foo(val fooString: String = "", val fooInt: Int = 0) {
    fun increaseTwo() = copy(fooInt = fooInt + 2)
    fun increaseThree() = copy(fooInt = fooInt + 3)
}

And you can use it like this

println( Foo("foo",2).increaseTwo().increaseThree())

Output :

Foo(fooString=foo, fooInt=7)