TDC218SP | Trilha Kotlin - DSLs in a Kotlin Way

DSLs IN A
KOTLIN WAY
Ubiratan Soares
July / 2018
VERSION
2.0

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

Type Aliases
Sealed Classes
Extension Functions
Extension Properties
ETC

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"
👌

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)

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

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

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

val items = mutableListOf(1, 2, 3)
items += 4

val items = mutableListOf(1, 2, 3)
items += 4
/#$
* Adds the speciﬁed [element] to this mutable collection.
%&
@kotlin.internal.InlineOnly
public inline operator fun <T> MutableCollection<in T>.plusAssign(element: T) {
this.add(element)
}

typealias IntPair = Pair<Int, Int>
val calendar by lazy {
Calendar.getInstance()
}

operator fun Date.plus(args: IntPair): Date {
calendar.time = this
calendar.add(args.ﬁrst, args.second)
return calendar.time
}
operator fun Date.minus(args: IntPair): Date {
calendar.time = this
calendar.add(args.ﬁrst, -args.second)
return calendar.time
}

fun Int.days() =
Calendar.DAY_OF_YEAR to this
fun Int.months() =
Calendar.MONTH to this
val atPast = Date() - 2.months()
val atFuture = Date() + 15.days()

val past = Date() - 2.months
val future = Date() + 15.days
👌
val Int.days: IntPair
get() = Calendar.DAY_OF_YEAR to this
val Int.months: IntPair
get() = Calendar.MONTH to this

A The problem
like with spannables
on Android

val toSpan = SpannableStringBuilder()
val start = toSpan.length
toSpan.append("First Part")
toSpan.setSpan(
UnderlineSpan(),
start,
toSpan.length,
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
)
toSpan.setSpan(
StyleSpan(android.graphics.Typeface.BOLD),
start,
toSpan.length,
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
)
toSpan.append("not bold or underlined")

operator fun SpannableString.plus(s: String) =
SpannableString(TextUtils.concat(this, s))
operator fun SpannableString.plus(s: SpannableString) =
SpannableString(TextUtils.concat(this, s))

fun span(given: CharSequence, span: Any): SpannableString {
val spannable =
if (given is String) SpannableString(given)
else given as? SpannableString ?: throw CannotBeSpanned
return spannable.apply {
setSpan(span, 0, length, SPAN_EXCLUSIVE_EXCLUSIVE)
}
}
object CannotBeSpanned : IllegalArgumentException(
"Cannot apply span. Should be String or SpannableString"
)

// Add more hooks to same span() function
fun italic(given: CharSequence) =
span(given, StyleSpan(Typeface.ITALIC))
fun underline(given: CharSequence) =
span(given, UnderlineSpan())
fun bold(given: CharSequence) =
span(given, StyleSpan(Typeface.BOLD))

val spanned =
"normal" +
bold("bold") +
italic("italic")
label.setText(spanned)

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)

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
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/

val starWars = query {
allFilms {
ﬁlm { title director }
}
}
println(starWars)
> query { allFilms { film { title director } } }

'( TODO
}

'( TODO
}
fun query(): String {
return "query { ${ '( Something here } }"
}

'( TODO
}
fun query(setup: AllFilmsBlock.() !" String) =
"query { ${setup(AllFilmsBlock())} }"

fun query(setup: AllFilmsBlock.() !" String) =
"query { ${setup(AllFilmsBlock())} }"
allFilms { // TODO }
}
class AllFilmsBlock {
fun allFilms(setup: FilmBlock.() !" String) =
"allFilms { ${setup(FilmBlock())} }"
}

allFilms {
ﬁlm {
// TODO
}
}
}

allFilms { film { } }
}
class FilmBlock {
fun film(setup: FilmFields.() !" String) =
with(FilmFields()) {
setup()
"film { ${fields()} }"
}
}

allFilms { film { } }
}
class FilmBlock {
fun film(setup: FilmFields.() !" String) =
with(FilmFields()) {
setup()
"film { ${fields()} }"
}
}

class FilmFiels {
private val picked = mutableListOf<String>()
fun ﬁelds() = TODO()
val title: String
get() {
picked.add(TITLE)
return TITLE
}
}

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

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

allFilms {
ﬁlm {
title
director
}
}
}
println(starWars)

// 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
}

// DSL based
val server = newServer {
enqueueMock {
code = 200
response = "OK"
}
}
server.start()
// Plain old mockWebServer
val server = MockWebServer()
val response = MockResponse().apply {
setResponseCode(503)
setBody("Ops!")
}
server.enqueue(response)
server.start()

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 !

https://speakerdeck.com/ubiratansoares

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

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

TDC218SP | Trilha Kotlin - DSLs in a Kotlin Way

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à TDC218SP | Trilha Kotlin - DSLs in a Kotlin Way

Similaire à TDC218SP | Trilha Kotlin - DSLs in a Kotlin Way (20)

Plus de tdc-globalcode

Plus de tdc-globalcode (20)

Dernier

Dernier (20)

TDC218SP | Trilha Kotlin - DSLs in a Kotlin Way