A modern programming language that makes developers happier.

kotlinlang

<https://medium.com/square-corner-blog/kotlinpoet-1-0-is-here-a3c771c92d47>

omg, these builders… Of course, Java API and all, but…

<@U1J7LS3N0> seriously, why not an idiomatic DSL?

Found the discussion here: <https://github.com/square/kotlinpoet/issues/62>

We've had an ongoing discussion about this ever since the early days of KP, and came to the conclusion that builders are still the most flexible approach in our case

I would be very interested to read a blog post about making the decision here :wink:

Yeah, I can try to compile all the pro/cons into a blog post

Anyway, people are successfully building their own DSLs on top of KP, which I think is a win

Agree, I think a DSL can be easily generated with some reflection and KotlinPoet :slightly_smiling_face: But a standard one maintained with the lib to avoid desyncs would still be nice.

Hm, I disagree with <@U0BFDUP0E> here: <https://github.com/square/kotlinpoet/issues/435#issuecomment-410533943>
DSLs are as composable as builders, you just pass a builder as a reciever instead of a parameter. Same extract function facilities, same reusability. May be I’m missing something important :man-shrugging:  There is also several mentions of “builders API is more flexible”, but without any real cases when something is doable with builders and not doable (or has other cons) with DSL.

Classic DSLs pretty much confine you to the property definitions, so if `FunSpec` has a `kdoc: CodeBuilder` property, you can either set it, or modify it if it's mutable, but you can't expose APIs such as `addKdoc(format: String, vararg args: Any?)`

Well, you might invent your own syntax to achieve this of course

Nice! Now if we could have a Gradle plugin that (when compiling Kotlin files) takes as input the ASTs of the elements annotated by some annotations and allows to generate new FileSpecs, it would be awesome :slightly_smiling_face:

That's pretty much what SQLDelight does, only that it compiles SQL into Kotlin

I wrote a Gradle plugin with Kotlinpoet. It is good! Builders are not really a problem once you are into it. Some simple things should be easier IMHO like a TypeSpec with properties defined in the constructor

<@U1J7LS3N0> I didn’t understand this:
&gt; Classic DSLs pretty much confine you to the property definitions
you can have a `kdoc { … }` or whatever signature you want in the DSL. Basically it can look something like this:
```
type {
    primaryConstructor { 
           kdoc("Creates an instance")
    }
    property&lt;String&gt;("foo", "initExpression()") 
}
```