Does a combination of

data class

and builder pattern exist, or is it even possible? I'd like the simplicity of a data class, but with setters that return

this

... Anyone?

You really don’t need a builder pattern if you use default argument values on the data-class’ constructor

I hardly believe default values make the setters return

this

. Whether I need a builder pattern or not is a different question.

what's the use case?

If you use a data class, and default values, and named parameters, and you're only coding in Kotlin, then you shouldn't need/want the builder pattern. If you want a function to set and return this, you'll have to code it yourself, but

apply

helps with that.

.apply { }

is the simple way to turn anything into a Builder pattern. Or if the data class is immutable, you’ll need to use

.let { }

and copy the object in each callback

data class MyDataClass(val param1: Int = 1, val param2: String = "", val param3: Boolean = false)
...
val data = MyDataClass(param2 = "Hello")
val data2 = MyDataClass(
    param1 = 2,
    param2 = "Two",
    param3= true
)
val data3 = data.copy(param3 = true)

I see no need for a builder-pattern with default argument values. If you need one for some reason, you’d have to roll your own, with a

Builder

inner class with mutable properties, building an immutable data-class.

Yes. I'd like one in a K/JS project where I expose certain data class like objects to users, and instead of letting them insert 6 or 10 or 15 different properties in one long constructor, I like to present them with a builder.

That (avoiding the need to provide too many arguments) you can accomplish with default argument values, requiring the users of your class to only provide the values that are different/non-default.

No. Sometimes, I cannot give defaults.

? Then how does you builder pattern work, where the user of your class has to provide the value of all arguments/setters?

Besides, you have answered my question long ago: a combination of

data class

and builder pattern does not exist out of the box.

If you are worried about readability, the users of your class can use the named-argument way of providing values to the constructor, to make the call to the constructor more clear. Note; if your (data) class is not immutable, just use

MyDataClass().apply { ..... }

and set the mutable properties in the `apply`’s lambda

Yeah, well, I won't use data classes, and that really solves my case. Thanks again.

Yeah, nothing exists out of the box for this. But you might also consider creating a DSL for configuring these objects instead of the traditional Java-style Builder pattern https://kotlinlang.org/docs/reference/type-safe-builders.html

JS