つくってあそぼ Kotlin DSL 第2版

DSL
• domain-speciﬁc language/ )
• DSL
(wikipedia )
•

Builder
//Java
Human human= new Human.Builder()
.setName("Kamedon")
.setAge(30)
.build();
//Kotlin
class Human(val name: String, val age: Int)
Human(age = 30, name = "Kamedon")
if(human.isAdult()){
//成人だったらなにかする
}

Build DSL
buildscript {
ext.kotlin_version = '1.2.70'
repositories {
google()
jcenter()
maven {
url 'http://kamedon.github.com/Validation/repository'
}
}
dependencies {
classpath 'com.android.tools.build:gradle:3.1.4'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:
$kotlin_version"
}
}
•

Layout Anko)
verticalLayout {
val name = editText()
button("Say Hello") {
onClick { toast("Hello, ${name.text}!") }
}
}
•
• LinearLayout

DI DSL(Kodein)
Kodein {
bind<Presenter>() with singleton {
Presenter(instance(), inetance())
}
}
val presenter: Presenter by instance()
•
•

DSL
•
•
• IDE
• Sansan Kotlin DSL

DSL
•
•
• Kotlin  
Java DSL
• DSL Kotlin

• Validation DSL
• DSL
• Validation  
https://github.com/kamedon/Validation

•  
•  
[ ] 
5 10  
[ ] 
20

DSL (1)
•
• 5
•
• A be B

DSL (2)
•
• 5  
• A be B  
not
• A be B not Message

DSL
be not
be not
be not
be not
be not

Validation<User> {
"name"{
be { name.isNotBlank() } not "入力してください"
be { name.length >= 5 } not "5文字以上入力"
be { name.length <= 10 } not "10文字以下で入力"
}
"age"{
be { age >= 0 } not "入力してください"
be { age >= 20 } not "20歳以上で入力"
}
}
•

•
• Pair Triple  
Build
•  
DSL
• DSL

data class User(val name: String, val age: Int)
class ValidationTest {
@Test
fun dslTest() {
Validation<User> {}
}
}

Validation<User> {}
• operator invoke companion object  
• companion object Java static
•
•

operator invoke
• Kotlin +,-, a..b , a in b,  
• invoke
class K {
operator fun invoke(value: Int) = value * 1000
}
val k = K()
k.invoke(1)
k(1) // invokeは省略可能

fun Int.k() = this * 1000
val kg = 1.k() //1000
public static final int k(int $receiver) {
return $receiver * 1000;
}
}
•
• static
•

+ operator invoke
• operator invoke
operator fun String.invoke(){}
"name"() 
operator fun String.invoke(f: ()->Unit){}
"name"({})
"name"{}

• Lambda)
• Syntax Suger
val kg: (Int) -> Int = fun(value: Int): Int {
return value * 1000
}
val kg = { value: Int -> value * 1000 }
kg.invoke(1) //invokeメソッドが作られる
kg(1) //invokeは省略可能

class Sample {
fun task(f: (String) -> Unit) {
//taskする
f("Hello")
}
fun task2(f: String.() -> Unit) {
//taskする
"Hello".f()
}
}

class Test {
fun task() {
val sample = Sample()
sample.task {
print(this::class.java.name)
print(it.length)
}
sample.task2 {
print(this::class.java.name)
print(length)
}
}
}

// f: String.() -> Unit)
public static final String f(@NotNull String $receiver)
// f: (String) -> Unit)
public static final String f($receiver: Test, @NotNull String it)
•
• {} this

Validation{}
class Validation<T> {
companion object {
operator fun <T>
invoke(init: Validation<T>.() -> Unit): Validation<T> {
return Validation<T>().apply(init)
}
}
}
public inline fun <T> T.apply(block: T.() -> Unit): T {
block()
return this
}

@Test
fun dslTest() {
Validation<User> {
"name"{}
}
}
•
• {}
• +

{}
operator fun String.invoke(init: () -> Unit)
}
• Validation  
Validation
•

{}
•
• ChildValidation
• {} ChildValidation
• ChildValidation
• ChildValidation Validation

{}
val validations = mutableMapOf<String, ChildValidation<T>>()
operator fun String.invoke(
init: ChildValidation<T>.() -> Unit
) {
validations.put(this, ChildValidation<T>().apply(init))
}
}
•
• String.invoke ChildValidation
• ChildValidation Validations

be {}
@Test
fun dslTest() {
Validation<User> {
"name"{
be { name.isNotBlank() }
}
}
}
•
be
• name

"name"{
be { name.isNotBlank() }
this.be { name.isNotBlank() }
this.be({ name.isNotBlank() })
this.be({ this.name.isNotBlank() })
}
•  
ßbe

operator fun String.invoke(init: ChildValidation<T>.() -> Unit)
}
class ChildValidation<T> {
fun be(f: T.() -> Boolean) {}
}
•
• String{} ChildValidation
• be ChildValidation
• User(T)
• T boolean

(inﬁx)
infix fun Int.k(str: String): String {
return "${this * 1000}$str"
}
val kg = 1.k("g") //1000g
val kg = 1 k "g" //1000g
•
• 1 inﬁx
•

be {} not message
@Test
fun dslTest() {
Validation<User> {
"name"{
}
}
}
•
be not
not

val validation = be { name.isNotBlank() } not "入力してください"
if(!validation(user)) {
return errorMessage
}
•  
1
• {} not
• be {} /

fun be(f: T.() -> Boolean) = f
infix fun (T.() -> Boolean).not(message: String)
}
•
• be
• not
DSL

class Validation<T>
(val validations: Map<String, ChildValidation<T>>)
val validations: MutableList<Pair<T.() -> Boolean, String>>
= mutableListOf()
}
• ChildValidation Validation
• <Pair<T.() -> Boolean, String> ChildValidation

ChildValidation
"name"{
be { name.length >= 0 } not "５文字以上で入力"
}
val validations =
mutableListOf<Pair<T.() -> Boolean, String>>()
infix fun be(f: T.() -> Boolean) = f
infix fun (T.() -> Boolean).not(message: String) {
validations.add(Pair(this, message))
}
}

Validation
ChildValidation
Validation<User> {
"name"{
}
}
operator fun String.invoke(init: ChildValidation<T>.() -> Unit) {
}
}
•

DSL
Validation<User> {
"name"{
}
}
}
companion object {
inline operator fun <T> invoke(
init: Validation<T>.() -> Unit): Validation<T> {
}
}
}

DSL
val validations = mutableListOf<Pair<T.() -> Boolean, String>>()
infix fun be(f: T.() -> Boolean) = f
infix fun (T.() -> Boolean).not(message: String) {
validations.add(Pair(this, message))
}
}
•

DSL
Validation<User> {
"name"{
}
"age"{
}
}
•
validate

Validate
fun validate(value: T): Map<String, List<String>> {
val messages = mutableMapOf<String, List<String>>()
validations.forEach { map ->
val errors = map.value.validations.asSequence()
.filter { !it.first.invoke(value) }
.map { it.second }
.filter { it.isNotEmpty() }
.toList()
if(errors.isNotEmpty()){
messages.put(map.key, errors)
}
}
return messages
}
}

DSL OK
val user = User("kamedon", 30)
val v = Validation<User> {
"name"{
}
"age"{
}
}
v.validate(user)
•

DSL NG
val user = User("k", 10)
val v = Validation<User> {
"name"{
}
"age"{
}
}
v.validate(user)
{name=[5文字以上入力], age=[20歳以上で入力]}
•

• Pair
• Builder var build val
• mutable immutable
• DSL

DSL Builder
}
companion object {
init: Validation<T>.() -> Unit): Validation<T> {
}
}
fun validate(value: T): Map<String, List<String>>
}

DSL Builder
class ValidationBuilder<T> {
}
fun build(): Validation<T> {
return Validation(validations)
}
}
class Validation<T>(val validations: Map<String, ChildValidation<T>>) {
companion object {
init: ValidationBuilder<T>.() -> Unit): Validation<T> {
val builder = ValidationBuilder<T>().apply(init)
return builder.build()
}
}
}

• object DSL
• inline GC
•
• interface

Validation<User> {
"name"{
be { name.length >= 5 } not "5文字以下"
be { name.length <= 10 } not "10文字以下"
}
"age"{
be { age >= 20 } not error message { "20歳以上" }
be { age <= 150 } not with callback ("150歳以下"){
print("callback")
}
}
}
•

• Java
• DSL
• IDE DSL
• DSL

• var val : Builder
• {} : lambda lambda
• ()
• : operator invoke
• : (Extensions Functions or
Properties)
• : inﬁx)

• DSL
•
•  
Validation GitHub  
11/2

つくってあそぼ Kotlin DSL 第2版

つくってあそぼ Kotlin DSL 第2版

Recommended

Recommended

More Related Content

What's hot

What's hot (18)

Similar to つくってあそぼ Kotlin DSL 第2版

Similar to つくってあそぼ Kotlin DSL 第2版 (20)

Recently uploaded

Recently uploaded (20)

つくってあそぼ Kotlin DSL 第2版