A modern programming language that makes developers happier.

kotlinlang

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.

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.

So the question is actually the other way around: do I need a `data class`? It sure would simplify a few things, but it seems I have to code a bit myself whether I do it the one way or the other.

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.

?
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>