つくってあそぼ 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

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

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版

More Related Content

What's hot (18)

Recently uploaded (20)

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