I was wondering if it's possible to have immutable lists/arrays inside a data class that's also itself immutable that's also a recursive DSL Something like this:

@JsExport
@Serializable
@ExperimentalJsExport
@Suppress("ArrayInDataClass")
data class Field(

	@JsName("name")
	val type: String? = type,

	@JsName("name")
	val name: String? = type,

	@JsName("children")
	var children: Array<Field> = arrayOf(),  // <<<--- this var is bugging me

	@Transient
	val handler: (Field.() -> Unit)? = null,

) {

	init {
		handler?.invoke(this@Field)
	}

	fun addChild(field: Field): Field {
		return this.copy(
			children = arrayOf(*this.children, field)
		)
	}


	fun field(
		name: String? = null,
		handler: (Field.() -> Unit)? = null,
	): Field {
		return Field(
			name = name ?: "${this@Field.name}.$type",
			value = value,
			type = type,
		).let {
			this.children += it  // <<<--- this is the reason for the var children instead of val children
			handler?.invoke(it)
			it
		}
	}

}

The DSL when used is something like this (I've simplified it removing unimportant fields):

val field = Field(
   name = "main",
) {
   field(
      name = "main",
   ) {
      field(type = "column") {
         field(type = "blah1")
      }
      field(type = "column") {
         field(type = "group") {
            field(type = "blah2.1")
            field(type = "blah2.2")
         }
         field(type = "group") {
            field(type = "blah2.3")
            field(type = "blah2.4")
         }
      }

   }
},

This field is to be used inside a MutableStateFlow, so whenever you add a child, it triggers the MutableStateFlow to emit to all Observers

// adding a child programatically:
mutableStateFlow.getAndUpdate {
   it.copy(
      field = field.addChild(someOtherField)
   )
}

Only problem is, it's also possible to modify the original children in the Field class and if I make it immutable (val), then the DSL use-case seems tricky - it'll need an internal private list, but I can't override getters inside a data class to include the internal children and if I change the data class to a regular class, I lose the ability to copy. What is the clean way of getting this right assuming DSL and Immutability is doable?

https://kotlinlang.org/community/slackccugl.html "If the code you are pasting is longer than a few lines, use "Code or text snippet" available from + menu next to message input. Only first few lines will be displayed to all users and people interested in the code can expand your code to look into details."

Apologies for the long code dump, code snippets is for some reason no longer available in my Slack or the way to add them has changed - it has been a while since I used Slack. That pattern looks interesting, I guess the only thing different is that I'll need to use FieldBuilder(name = ...) { } instead of Field(name = ...) { }, which seems like an acceptable trade-off. Thanks for the help!

Slack has hidden snippets away in the "browse all shortcuts" menu by default, but you can still find it by name. or you can put the long code blocks in a thread.

I'll delete this post in a bit, doesn't seem like I can add snippets afterwards. FieldBuilder.() : yes, I was thinking that too, that'll give me 100% what I was looking for!

https://kotlinlang.org/docs/coding-conventions.html#function-names "factory functions used to create instances of classes can have the same name as the abstract return type"