Kotlin dsl

About me :)
‣ Roque Buarque Junior
‣ Brazilian
‣ Android Engineer
‣ Berlin - Germany
‣ Sharenow
‣ @roqbjr

KOTLIN - DSL
WHAT YOU WILL SEE?
▸What is DSL?
▸DSL Examples
▸Kotlin features to build a DSL
▸Code
▸Code
▸And more CODE

KOTLIN - DSL
KOTLIN IN ACTION
▸Chapter 11 - DSL Construction

A DOMAIN-SPECIFIC
LANGUAGE (DSL) IS A COMPUTER
LANGUAGE SPECIALIZED TO A
PARTICULAR
APPLICATION DOMAIN. THIS IS IN
CONTRAST TO A GENERAL-
PURPOSE LANGUAGE (GPL),
WHICH IS BROADLY APPLICABLE
ACROSS DOMAINS. From Wikipedia
KOTLIN - DSL

KOTLIN - DSL
val list = mutableListOf("A", "B", "C").toList()
val list = buildList {
add("A")
add("B")
add("C")
}

KOTLIN - DSL
HIGHER-ORDER FUNCTIONS AND
LAMBDAS
▸Store in variables and data structures
▸Pass as argument to and return from other function
A higher-order function is a function that takes functions as parameters, or returns a function.

KOTLIN - DSL
class Person {
lateinit var name: String
lateinit var email: String
}

KOTLIN - DSL
class Person {
}
val person = Person()
person.name = "Roque"
person.email = "roque@email.com"

KOTLIN - DSL
class Person {
}
Person()
.apply {
this.name = "Roque"
this.email = "roque@email.com"
}

KOTLIN - DSL
class Person {
}
Person()
.apply {
name = "Roque"
email = "roque@email.com"
}

KOTLIN - DSL
val helloWorld = "Hello".apply {
"$this World"
}
Hello

KOTLIN - DSL
Person()
.apply {
name = "Roque"
email = "roque@email.com"
}
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}

KOTLIN - DSL
Person()
.let {
it.name = "Roque"
it.email = "roque@email.com"
}

KOTLIN - DSL
val helloWorld = "Hello".let {
"$it World"
}
Hello World

KOTLIN - DSL
Person()
.let {
it.name = "Roque"
it.email = "roque@email.com"
}
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}

KOTLIN - DSL
fun helloWorld(block: () -> Unit) {
println("Hello World")
block()
}
helloWorld{ }
Hello World

KOTLIN - DSL
fun helloWorld(block: (String) -> Unit) {
println("Hello")
block("World")
}
helloWorld{
print(it)
}
Hello
World

KOTLIN - DSL
fun helloWorld(block: String.(String) -> Unit) {
block(“Hello”, “World”)
}
helloWorld{
print(“$this $it”)
}
Hello World

KOTLIN - DSL
fun <T> T.helloWorld(block: T.() -> Unit) {
block(this)
}
"Hello".helloWorld {
print(this)
}
Hello

KOTLIN - DSL
fun <T, R> T.helloWorld(block: T.() -> R) : R {
return block(this)
}
val helloWorld = "Hello".helloWorld {
"$this World"
}
print(helloWorld)
Hello World

KOTLIN - DSL
HTML
<table>
<tr>
<td> cell </td>
</tr>
</table>

KOTLIN - DSL
HTML
"<table>
<tr>
<td> cell </td>
</tr>
</table>"

KOTLIN - DSL
HTML
“<table>
<tr>
<td> cell </td>
</tr>
</table>"
createHTML().
table {
tr {
td { +”cell” }
}
}
https://github.com/Kotlin/kotlinx.html

KOTLIN - DSL
SQL
SELECT *
FROM users
WHERE age = 18

KOTLIN - DSL
SQL
"SELECT *
FROM users
WHERE age = 18”

KOTLIN - DSL
EXPOSED - JETBRAINS
https://github.com/JetBrains/Exposed/
"SELECT *
FROM users
WHERE age = 18”
Users.select {
Users.age eq 18
}

KOTLIN - DSL
SQL
User select { age eq 18 }

KOTLIN - DSL
INFIX
▸Must be member function or extension function
▸Must have only a single parameter
▸The parameter must have no default value
▸The parameter must not accept varargs
▸Receiver and parameter must be specified
Functions marked with the infix keyword can also be called using the infix notation(omitting the dot and the
parentheses for the call)

KOTLIN - DSL
object User {
operator fun invoke(query: String): User {
this.query += query
return this
}
infix fun select(block: User.() -> Unit) {
User("SELECT * FROM users").block()
}
}

KOTLIN - DSL
object User {
private var query = ""
val age: User
get() = this.where("age")
val name: User
get() = this.where("name")
private fun where(field: String): User {
query+= " WHERE $field"
return this
}
infix fun eq(age: Int) {
println("$query = $age")
}
}

KOTLIN - DSL
SQL
User select { age eq 18 }
SELECT * FROM users WHERE age = 18

KOTLIN - DSL
CAKE
val cake = Cooker make Cake of Chocolate and Coconut withOut
Sugar forMy Birthday
print(cake)

KOTLIN - DSL
INFIX
class Cooker {
}

KOTLIN - DSL
INFIX
class Cooker {
fun make(value: Dish)
{
. . .
}
}
Cooker().make(Cake())

KOTLIN - DSL
INFIX
class Cooker {
infix fun make(value: Dish)
{
. . .
}
}
Cooker() make Cake()

KOTLIN - DSL
INFIX
object Cooker {
infix fun make(value: Dish)
{
. . .
}
}
Cooker make Cake()

KOTLIN - DSL
SEALED CLASS
▸Is abstract by itself, cannot be instantiated
▸Not allowed to have non-private constructors (their
constructors are private by default).
Sealed classes are used for representing restricted class hierarchies, when a value can have one of the
types from limited set, but cannot have any other type.

KOTLIN - DSL
SEALED CLASSES
class Ingredients{
}

KOTLIN - DSL
SEALED CLASSES
sealed class Ingredients{
}

KOTLIN - DSL
SEALED CLASSES
object Chocolate : Ingredients()
object Coconut : Ingredients()
object Sugar : Ingredients()
}

KOTLIN - DSL
SEALED CLASSES
}
private fun convertFlavorToString(ing: Ingridient): String {
return when (ing) {
is Ingredients.Chocolate -> "Chocolate"
is Ingredients.Coconut -> "Coconut"
}
}

KOTLIN - DSL
SEALED CLASSES
}
* when expression must be exhaustive
return when (ing) {
}
}

KOTLIN - DSL
SEALED CLASSES
}
return when (ing) {
is Ingredients.Sugar -> "Sugar"
}
}

KOTLIN - DSL
SEALED CLASSES
sealed class Ingredients
return when (ing) {
is Ingredients.Sugar -> "Sugar"
}
}

KOTLIN - DSL
SEALED CLASSES
sealed class Ingredients
return when (ing) {
is Chocolate -> "Chocolate"
is Coconut -> "Coconut"
is Sugar -> "Sugar"
}
}

KOTLIN - DSL
SEALED CLASSES - SMART CASTING
sealed class VehicleState
object Empty : VehicleState()
data class Success(val vehicles: List<Vehile>) : VehicleState()
data class Error(error: Throwable) : VehicleState()
data class Loading(isLoading: Boolean) : VehicleState()

KOTLIN - DSL
SEALED CLASSES - SMART CASTING
sealed class VehicleState
object Empty : VehicleState()
data class Success(val vehicles: List<Vehile>) : VehicleState()
data class Error(error: Throwable) : VehicleState()
data class Loading(isLoading: Boolean) : VehicleState()
private fun updateState(state: VehicleState) {
when (state) {
is Empty -> ...
is Success -> state.vehicles
is Error -> state.error
is Loading -> state.isLoading
}
}

KOTLIN - DSL
SEALED
CLASS
Cooker
Cake
Chocolate
Coconut
Sugar
Birthday
make
of
and
withOut
forMy
INFIX

KOTLIN - DSL
UNIT TEST
data class User(val name:String, var balance: Double) {
fun withDraw(value: Double){
this.balance -= value
}
}

KOTLIN - DSL
UNIT TEST
//Given
val user = User("Roque", 200.0)
//When
user.withDraw(50.0)
//Then
Truth.assertThat(user.balance).isEqualTo(150.0)

KOTLIN - DSL
UNIT TEST
given {
User("Roque", 200.0)
}.test {
withDraw(50.0)
}.assert {
Truth.assertThat(balance).isEqualTo(150.0)
}

KOTLIN - DSL
UNIT TEST
fun <T, R> T.given(block: () -> R): R {
return block(this)
}

KOTLIN - DSL
UNIT TEST
fun <T> T.test(block: T.() -> Unit): T {
block()
return this
}

KOTLIN - DSL
UNIT TEST
fun <T> T.assert(block: T.() -> Unit) {
this.block()
}

KOTLIN - DSL
UNIT TEST
given {
User("Roque", 200.0)
}.test {
withDraw(50.0)
}.assert {
balance isEquals 150.0
}

KOTLIN - DSL
UNIT TEST
infix fun<T> T.isEquals(value: T):{
Truth.assertThat(this).isEqualTo(value)
}

KOTLIN - DSL
UNIT TEST
whenever(repository.increase()).thenReturn(Counter(1))

KOTLIN - DSL
UNIT TEST
repository.increase() willReturn Counter(1)

KOTLIN - DSL
UNIT TEST
repository.increase() willReturn Counter(1)
infix fun <T> T.willReturn(value: T) {
given(this)
.willReturn(value)
}

KOTLIN - DSL
NEXT STEPS
▸Find your necessity
▸Check if already exist
▸Sync with your team
▸Be creative
▸Enjoy more readable code :)

KOTLIN - DSL
SUMMARIZE
▸Infix notation
▸Sealed Class
▸Higher order functions
▸Lambda with receivers
▸Lambda parameter
▸Operator overloading

Kotlin dsl

Recommended

Recommended

More Related Content

Similar to Kotlin dsl

Similar to Kotlin dsl (20)

Recently uploaded

Recently uploaded (20)

Kotlin dsl

Editor's Notes