Kotlin DSLs and How to Build Them

Kotlin DSLs and How To Build Them Subhrajyoti Sen smallcase

Domain Speciﬁc Language A DSL is a computer language specialized
to a particular application domain. This is contrast to a general-purpose language (GPL), which is broadly applicable across domains. -Wikipedia

Examples - HTML <html> <body> <h1>My First Heading</h1> <p>My first
paragraph.</p> </body> </html> <html> <body> <h2>An Unordered List</h2> <ul> <li>Coffee</li> <li>Tea</li> </ul> </body> </html>

Examples - CSS div { background-color: lightgrey; width: 300px; padding:
50px; } h1 { font-size: 40px; } h2 { font-size: 30px; }

Examples - SQL SELECT * FROM Customers WHERE Last_Name=”Sen” SELECT
First_Name, Nickname FROM Friends WHERE Nickname like ‘%brain%’

Where’s my Kotlin?

Examples - HTML val html = document.create.html { head {
title("Hello world") } body { h1("h1Class"){ +"My header1" } } } https://github.com/Kotlin/kotlinx.html

Examples - CSS val css = Stylesheet { a {
width = 10.px color = 0xffffff hover { color = 0xf2cacf } } } https://github.com/olegcherr/Aza-Kotlin-CSS

Examples - SQL val row = from(Friends) .where { Nickname
like "brian" } .select(Friends.First_name, Friends.Nickname) https://github.com/orangy/squash

Examples - SQL https://github.com/arunkumar9t2/transition-x

Advantages There must be a reason DSL exists and developers
write customs DSLs

write customs DSLs • Expressive

write customs DSLs • Expressive • Readable

write customs DSLs • Expressive • Readable • Concise - Less Boilerplate

conference { name = "DevConfIN 19" location = "Bengaluru" room
{ roomNumber = 1 floor = 2 speaker { name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" } } room { roomNumber = 2 floor = 3 speaker { name = "Sayantika Banik" talkTitle = "Open Source" } } }

Why Kotlin? Kotlin provides certain features that let us develop
expressive and structured DSL • Lambda with Receiver • Lambda as method parameter • Extension function

val speaker = speaker { name = "Subhrajyoti Sen" talkTitle
= "Intro to Kotlin DSL" }

= "Intro to Kotlin DSL" } Function

data class SpeakerModel( var name: String = “”, var talkTitle:
String = “” )

fun speaker() { }

fun speaker(): SpeakerModel { }

fun speaker(): SpeakerModel { val speaker = SpeakerModel() }

fun speaker(): SpeakerModel { val speaker = SpeakerModel() return speaker
}

fun speaker(block: (SpeakerModel) -> Unit): SpeakerModel { val speaker =
SpeakerModel() return speaker }

Lambda

Lambda Lambdas are code blocks enclosed in curly braces.

Lambda Lambdas are code blocks enclosed in curly braces. val
multiply: (Int, Int) -> Int

multiply: (Int, Int) -> Int val multiply = { a: Int, b: Int -> a*b }

multiply: (Int, Int) -> Int val multiply = { a: Int, b: Int -> a*b } println(multiply(3,4))

SpeakerModel() return speaker }

SpeakerModel() block(speaker) return speaker }

val speaker = speaker({ it.name = "Subhrajyoti Sen" it.talkTitle =
"Intro to Kotlin DSL" })

fun speaker(block: SpeakerModel.() -> Unit): SpeakerModel { val speaker =

SpeakerModel() block(speaker) return speaker } Receiver Lambda

SpeakerModel() speaker.block() return speaker }

val speaker = speaker({ this.name = "Subhrajyoti Sen" this.talkTitle =

val speaker = speaker({ name = "Subhrajyoti Sen" talkTitle =

"Intro to Kotlin DSL" }) Extra bracket?

Lambda as a Parameter fun modify(a: Int, lambda: (Int) ->
Int)

Int) modify(3, someLambda)

Int) modify(3, someLambda) modify(3) { }

= "Intro to Kotlin DSL" }

room { roomNumber = 1 floor = 2 speaker {
name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" } }

data class RoomModel( var roomNumber: Int = 0, var floor:
Int = 99, var speaker: SpeakerModel? = null )

fun room(block: RoomModel.() -> Unit): RoomModel { val room =
RoomModel() room.block() return room }

But there’s a problem

Extension Function A function that extends the functionality without modifying
it fun Banner.isVisible(): Boolean { return this.visibility == Banner.VISIBLE }

it fun Banner.isVisible(): Boolean { return this.visibility == Banner.VISIBLE } Base class

it fun Banner.isVisible(): Boolean { return this.visibility == Banner.VISIBLE } Base class Extension function

SpeakerModel() speaker.apply(block) return speaker }

fun speaker(block: SpeakerModel.() -> Unit) { val speaker = SpeakerModel()
speaker.apply(block) return speaker }

fun speaker(block: SpeakerModel.() -> Unit) { val speaker = SpeakerModel()
speaker.apply(block) }

fun RoomModel.speaker(block: SpeakerModel.() -> Unit) { val speaker = SpeakerModel()
speaker.apply(block) }

fun RoomModel.speaker(block: SpeakerModel.() -> Unit) { val speaker = SpeakerModel()
speaker.apply(block) this.speaker = speaker }

val conference = conference { name = "DevConfIN 19" location
= "Bengaluru" room { roomNumber = 1 floor = 2 speaker { name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" } } }

data class ConferenceModel( var name: String = "", var location:
String = "", var rooms: MutableList<RoomModel> = mutableListOf() )

data class ConferenceModel( var name: String = "", var location:
String = "", var rooms: MutableList<RoomModel> = mutableListOf() ) Create an empty mutable list

fun conference(block: ConferenceModel.() -> Unit): ConferenceModel { val conference =
ConferenceModel() conference.apply(block) return conference }

fun ConferenceModel.room(block: RoomModel.() -> Unit) { val room = RoomModel()
room.apply(block) this.rooms.add(room) }

{ roomNumber = 1 floor = 2 speaker { name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" } } room { roomNumber = 2 floor = 3 speaker { name = "Sayantika Banik" talkTitle = "Open Source" } } }

Not yet done

{ roomNumber = 1 floor = 2 speaker { name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" } } }

{ roomNumber = 1 speaker { name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" floor = 2 } } }

This actually compiles and works

{ roomNumber = 1 speaker { name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" floor = 2 } } }

{ roomNumber = 1 speaker { name = "Subhrajyoti Sen" talkTitle = "Intro to Kotlin DSL" floor = 2 } } } Still inside the scope of room

Scope Control - DSL Marker The lambda should be able
to access only it’s nearest implicit receiver.

Scope Control - DSL Marker The lambda should be able
to access only it’s nearest implicit receiver. @DslMarker @Target(AnnotationTarget.TYPE) annotation class ConfDSL

fun RoomModel.speaker(block: SpeakerModel.() -> Unit) { // ... } fun
ConferenceModel.room(block: RoomModel.() -> Unit) { // ... } fun conference(block: ConferenceModel.() -> Unit): ConferenceModel { // ... }

fun RoomModel.speaker(block: (@ConfDSL SpeakerModel).() -> Unit) { // ... }
fun ConferenceModel.room(block: (@ConfDSL RoomModel).() -> Unit) { // ... } fun conference(block: (@ConfDSL ConferenceModel).() -> Unit): ConferenceModel { // ... }

To conclude, DSLs are awesome

Questions? http://bit.ly/DevConfDSL

Thank you SubhrajyotiSen iamsubhrajyoti

Kotlin DSLs and How to Build Them

Kotlin DSLs and How to Build Them

More Decks by Subhrajyoti Sen

Other Decks in Programming

Featured

Transcript