DSLs in a Kotlin Way

DSLs IN A KOTLIN WAY Ubiratan Soares June / 2018

INTERNAL LANGUAGE EXTERNAL LANGUAGE

SELECT * FROM accounts WHERE id=12345

SELECT * FROM accounts WHERE id=12345 " "

String sql = SQLiteQueryBuilder .select("*") .from("accounts") .where("id=12345") .toString(); https://github.com/alexfu/SQLiteQueryBuilder

<!DOCTYPE html> <html> <body> <h1>Hey!!"h1> <div>Ho!<span>Lets go!!"span> !"div> !"body> !"html>

val tree = createHTMLDocument().html { body { h1 { +"Hey"
} div { +"Ho!" span { +"Lets go!" } } } } https://github.com/Kotlin/kotlinx.html

--- punctuation --- overhead +++ grammar +++ structure

TYPE ALIASES

typealias UserId = String fun findUser(by: UserId) { TODO() }

typealias Seconds = Int typealias Duration = Int fun ellapsed(amount:
Seconds): Duration { TODO() }

// Can be used with function literals typealias Factory =
() !" User // Shine with Generics typealias StringTriplet = Triple<String, String, String> // Nice to abbreviate long names typealias OnPermissionResult = ActivityCompat.OnRequestPermissionsResultCallback

SEALED CLASSES

typealias Fee = Float sealed class Tax { class FederalTax(val
percent: Fee) : Tax() object Free : Tax() }

typealias Fee = Float sealed class Tax { class FederalTax(val
percent: Fee) : Tax() object Free : Tax() } fun evaluate(incoming: Tax) = when (incoming) { is Tax.FederalTax !" incoming.percent is Tax.Free !" 0.0f }

typealias Fee = Float sealed class Tax class FederalTax(val percent:
Fee) : Tax() object Free : Tax() fun evaluate(incoming: Tax) = when (incoming) { is FederalTax !" incoming.percent is Free !" 0.0f }

INFIX NOTATION

class Extractor { fun ﬁrstLetter(target: String) = target[0].toString() } val
k = Extractor().ﬁrstLetter("Kotlin")

class Extractor { infix fun firstLetter(target: String) = target[0].toString() }
val k = Extractor() firstLetter "Kotlin" NO PUNCTUATION!

object extract { inﬁx fun ﬁrstLetterOf(target: String) = target[0].toString() }

object extract { inﬁx fun firstLetterOf(target: String) = target[0].toString() }
val ﬁrst = extract firstLetterOf "Awesome"

object acronymn { infix fun from(target: String) = Chainer( initials
= mutableListOf(), seed = target ) }

class Chainer( private val initials: MutableList<String>, seed: String) { init
{ initials += seed.ﬁrst().toString() }

class Chainer(…) { init { initials += seed.ﬁrst().toString() } inﬁx
fun and(another: String) = Chainer(initials, another)

class Chainer(…) { inﬁx fun joinedWith(option: Joiner) = initials.reduce {
previous, letter !" val next = when (option) { is noPunctuaction !" letter is dots !" "$letter." } "$previous$next" }

sealed class Joiner object noPunctuaction : Joiner() object dots :
Joiner()

val dsl = acronymn from "Domain" and "Speciﬁc" and "Language"
joinedWith noPunctuaction //DSL

val dsl = acronymn from "Domain" and "Speciﬁc" and "Language"
joinedWith dots //D.S.L

EXTENSIONS

fun Boolean.nor(another: Boolean) = or(another).not() val nored = true.nor(false)

inﬁx fun Boolean.nand(some: Boolean) = and(value).not()

inﬁx fun Boolean.nand(some: Boolean) = and(value).not() val nanded = false
nand true

val calendar by lazy { Calendar.getInstance() } fun Date.tomorrow(): Date
{ calendar.time = this calendar.add(Calendar.DATE, 1) return calendar.time }

fun Date.yesterday(): Date { … } fun Date.before(some: Date): Boolean
{ … } fun Date.after(some: Date): Boolean { … } fun Date.isHolyday(): Boolean { … } fun Date.iso8601String(): String { … }

OPERATOR OVERLOADS

typealias IntPair = Pair<Int, Int> operator fun Date.plus(args: IntPair): Date
{ calendar.time = this calendar.add(args.ﬁrst, args.second) return calendar.time }

typealias IntPair = Pair<Int, Int> operator fun Date.minus(args: IntPair): Date
{ calendar.time = this calendar.add(args.ﬁrst, -args.second) return calendar.time }

fun Int.months() = Calendar.MONTH to this val atPast = Date()
- 2.months() fun Int.days() = Calendar.DAY_OF_YEAR to this val atFuture = Date() + 15.days() typealias IntPair = Pair<Int, Int>

fun Int.days() = Calendar.DAY_OF_YEAR to this val Int.days: IntPair get()
= days() fun Int.months() = Calendar.MONTH to this val Int.months: IntPair get() = months()

val now = Date() val past = now - 2.months
val future = now + 15.days NO MORE PARENTHESIS !!!

LAMBDAS + RECEIVERS

fun x(lambda: () !" Unit) { lambda() } fun y(lambda:
() !" Int) = lambda() val x: () !" Int = { TODO() } val result = x()

val add = fun(a: Int, b: Int) = a +
b fun calculate(func: (Int, Int) !" Int) { func.invoke(2,2) } // Trailling Notation calculate { a, b !" a + b } // Normal notation calculate(add)

// Lambdas are just another representation for // functions; they
are not DECLARED the same way // as function types val add = fun(a: Int, b: Int) = a + b val subtract: (Int, Int) !" Int = { a, b !" a - b } but passed / used as expressions as well fun report(operation: (Int, Int) !" Int) = println(operation.invoke(2, 2))

class Receiver(val data: Int) // Kotlin allows us to add
an extension function // literal to a type. Such lambda acquires the properties // of non-static method in the context class val addOne: Receiver.() !" Int = { data + 1 } val two = addOne(Receiver(1)) val twoAgain = Receiver(1).addOne()

fun receive(block: Receiver.() !" Unit) { val r = Receiver(data
= 1) block(r) // r.block() is exactly the same } receive { println(data) // 1 }

https://graphql.org/swapi-graphql/

fun main(args: Array<String>) { val starWars = query { allFilms
{ ﬁlms { title director releaseDate } } } }

val starWars = query { #$ TODO }

val starWars = query { #$ TODO } fun query():
String { #$ Something here return "query { ${ #$ Something here } }" }

val starWars = query { #$ TODO } fun query(build:
FilmsConnection.() -> Unit): String { val connection = FilmsConnection() connection.build() return "query { ${connection.block()} }" }

val starWars = query { #$ TODO } class FilmsConnection
{ fun block() = "allFilms { #$ Something here }" } fun query(build: FilmsConnection.() !" Unit): String { val connection = FilmsConnection() connection.build() return "query { ${connection.block()} }" }

val starWars = query { allFilms { ﬁlms { //
TODO } } }

class FilmsConnection { private val films = Films() fun allFilms(build:
Films.() !" Unit) = films.build() fun block() = "allFilms { ${films.block()} }" }

Films.() -> Unit) = ﬁlms.build() fun block() = "allFilms { ${ﬁlms.block()} }" }

Films.() -> Unit) = films.build() fun block() = "allFilms { ${films.block()} }" } class Films { private val film = Film() fun films(build: Film.() -> Unit) = film.build() fun block() = "films { ${film.block()} }" }

class Film { fun block() = TODO() }

class Film { private val picked = mutableListOf<String>() fun block()
= TODO() val title: String get() { picked.add(TITLE) return TITLE } private companion object { const val TITLE = "title" } }

class Film { val title: String get() { … }
val director: String get() { … } val releaseDate: String get() { … } private companion object { const val TITLE = "title" const val DIRECTOR = "director" const val RELEASE_DATE = "releaseDate" } }

class Film { fun block() = picked.distinct().joinToString(separator = " ")
val title: String get() { … } val director: String get() { … } val releaseDate: String get() { … } private companion object { … } }

fun main(args: Array<String>) { val starWars = query { allFilms
{ ﬁlms { title director releaseDate } } } println(starWars) // query { allFilms { films { title director releaseDate } } } }

// Plain old mockWebServer val server = MockWebServer() val response
= MockResponse().apply { setResponseCode(503) setBody("Ops!") } server.enqueue(response) server.start()

class MockResponseBuilder( #$ Aliases var code: Int = 0, var
response: String? = null) { fun mockResponse() = MockResponse().apply { setResponseCode(code) setBody(response) } }

class QueueBuilder { val mocks = mutableListOf<MockResponse>() fun enqueueMock(setup: MockResponseBuilder.()
!" Unit) { val builder = MockResponseBuilder() builder.setup() mocks.add(builder.mockResponse()) } }

typealias BuildMock = MockResponseBuilder.() !" Unit class QueueBuilder { val
mocks = mutableListOf<MockResponse>() fun enqueueMock(setup: BuildMock) = MockResponseBuilder().run { setup() mocks.add(mockResponse()) } }

typealias BuildQueue = QueueBuilder.() !" Unit fun newServer(setup: BuildQueue): MockWebServer
= with(MockWebServer()) { #$ ???? return this }

typealias BuildQueue = QueueBuilder.() !" Unit fun newServer(setup: BuildQueue): MockWebServer
= with(MockWebServer()) { QueueBuilder().run { setup() mocks.forEach { enqueue(it) } } return this }

val server = newServer { enqueueMock { code = 200
response = "OK" } } server.start()

FINAL  REMARKS

CONCLUSIONS • DSLs are fun (with no pun) • DSL-building
offer great insights over Kotlin features! • DSLs should work to improve an existing domain, not replace it • Design your own DSLs for fun and proﬁt !

CHECK THESE ONES ! https://github.com/kotlintest/kotlintest https://github.com/JetBrains/Exposed https://github.com/Kotlin/anko Anko Kotlintest Exposed

UBIRATAN SOARES Computer Scientist by ICMC/USP Software Engineer, curious guy
Google Expert for Android and Kotlin Teacher, speaker, etc, etc

https://speakerdeck.com/ubiratansoares

THANK YOU @ubiratanfsoares ubiratansoares.github.io https://br.linkedin.com/in/ubiratanfsoares

DSLs in a Kotlin Way

DSLs in a Kotlin Way

More Decks by Ubiratan Soares

Other Decks in Programming

Featured

Transcript