Kotlin DSL automatically add/generate to MutableList

Question

I've been struggling making DSL to work like this. I'd like to add items inside the lambda to the mutableList inside the persons. Can anybody help with this?

persons {
    Person("name")
    Person("name second")
}

the expected result after the lambda executed, all those item will be put inside the mutableList like this:

mutableListOf(Person("name"), Person("name second"))

John O'Reilly · Answer 1 · 2020-11-08T10:21:52.563

Not quite exactly as you have but should be able to use something like

data class Person(var name: String? = null)

class Persons : ArrayList<Person>() {
    fun person(block: Person.() -> Unit) {
        val person = Person().apply(block)
        add(person)
    }
}

fun persons(block : Persons.() -> Unit): Persons = Persons().apply(block)

fun main() {
    val personList = persons {
        person {
            name = "John"
        }
        person {
            name = "Jane"
        }
    }

    println(personList)
}

(This could be expanded then to use some kind of builder pattern to allow use of immutable vals in the data class)

I see, thanks for the explanation, its really helpful – DTechnlogy Nov 08 '20 at 12:38 — DTechnlogy, Nov 08 '20 at 12:38

score 2 · Accepted Answer · answered Nov 08 '20 at 10:59

Assuming that Person is a:

data class Person(val name: String)

Then the line Person("name") does nothing - it just desclares an unused instance. Person("name second") does the same (generally speaking, as it is the last line in lambda, it implicitly returned as the result of lambda expsession and theoretically, it could be handled later; anyway, that DSL syntax won't be working in general case).

You need not just declare instances, but also add them to list. So you need to declare some auxilary function (person for instance, to be close to desired syntax) which will do this under the hood:

class Persons {
    val delegate: MutableList<Person> = mutableListOf()

    fun person(name: String, block: Person.() -> Unit = {}) {
        delegate.add(Person(name).also(block))
    }
}

fun persons(block: Persons.() -> Unit) = Persons().also(block).delegate.toList() //mutation was needed only during construction, afterwards consider preserving immutability

Usage:

val persons: List<Person> = persons {
    person("name")
    person("name second")
}

I didn't think using function to emulate class creation. Thanks a lot for the explanation! — DTechnlogy, Nov 08 '20 at 12:38

Kotlin DSL automatically add/generate to MutableList

2 Answers2