Can a constructor be written as an extension method?

You can make a factory function on a class’s companion object, if it exists. The semantics of it are a bit strange and can be pretty unintuitive, but it can be done. For example:

operator fun String.Companion.invoke(any: Int) : String {
    return any.toString()
}

fun callStringFactory() {
    val s: String = String(123)
}

Ah awesome, I had stumbled onto something like that online

I don’t think you’ll be able to make a generic function out of it, since not all classes have companion objects, and there’s no way to declare an interface or anything on a class to mandate that it has one

Right, I was trying to get around it by using interfaces, but it wasn’t accessible, like you mentioned

You might go with an approach like Ktor, where you declare an interface on the companion object itself. And then the DSL function can look for that interface

interface DslCompanionInterface

sealed class Model {
    class A: Model() {
        companion object : DslCompanionInterface
    }
    class B: Model() {
        companion object : DslCompanionInterface
    }
}

class Dsl<T>() {
    operator fun T.invoke(block: ()->Unit) {

    }
}

fun <T : DslCompanionInterface> dsl(init: Dsl<T>.() -> Unit): Dsl<T> {
    // DSL boilerplate
}

val test = dsl<DslCompanionInterface> {
    Model.A {
        // Do stuff
    }
    Model.B {
        // Do stuff
    }
}

That looks pretty promising! I’ll give that approach a shot and play around with it