Domain specific language / DSL in kotlin

class Context {
    val info = "yuknight"
    val name = "AAA"

    fun toast(str: String) = println("toast:$str")
}

inline fun Context.myApply(lambda: Context.(String) -> Unit): Context {
    lambda(info)
    return this
}

inline fun File.applyFile(action: (String, String) -> Unit): File {
    setWritable(true)
    setReadable(true)
    action(this.name, this.readLines()[0])
    return this
}

fun main() {
    // Actually myApply Function is DSL Programming paradigm , Define rules such as input and output 
    //1. Define the whole lambda Rules and standards , Input   Must be Context This class , To call myApply function , Held in anonymous functions it and this
    //2. Define the whole lambda Rules and standards , Output   Always return Context In itself , So you can chain call 
    // then main The function can be based on DSL Programming mode standard rules to write specific implementation , This is it. DSL Programming paradigm 
    val context = Context().myApply {
        //it == String == "yuknight"
        println(" my it:$it, this:$this")
        toast("abcdefghijklmn")
        toast(it)
        toast(name)//this.name
        true
    }.myApply { }.myApply { }
    println(" Always output yes ：" + context.name)
    println()

    // Actually applyFile function , Namely DSL Programming paradigm , Define rules such as input and output 
    //1. Define the whole lambda Rules and standards , Input  File, Actually applyFile function , Held in anonymous functions fileName and data
    //2. Define the whole lambda Rules and standards , Output  File, So you can chain call 
    val file: File = File("D:\\a.txt")
        .applyFile { fileName, data ->
            println(" file name ：$fileName,  The content is ：$data")
            true// The last line does not affect the return value 
        }.applyFile { a, b -> }.applyFile { a, b -> }
    println(" Always output File In itself ："+ file.name)
}