One Source to Rule Them All

fun main() {
    if (conditionOneMet() && conditionTwoMet()) {
        runTransformationA()
    } else if ((ConditionIII.met() || ConditionIV.met()) && conditionOneMet()) {
        runTransformationB()
    } else if (conditionTwoMet()) {
        runTransformationC()
    }
}

private fun rules(): List<Rule> = listOf(
    Rule(ConditionII, TransformationC),
    Rule(Not(ConditionIV), TransformationB),
    Rule(And(ConditionI, ConditionII), TransformationA),
    Rule(Or(And(ConditionIII, ConditionIV), ConditionI), TransformationB)
)


fun main() {
    rules()
        .firstOrNull { it.condition.met() }
        ?.transformation?.run()
}

val rules: List<Rule> =
    // @formatter:off
    rules {
        ConditionI and ConditionIV         invokes TransformationA
        ConditionII                        invokes TransformationC
        not(ConditionIV)                   invokes TransformationB
        (ConditionI and not(ConditionIII)) invokes TransformationA
        (ConditionIII
                and ConditionIV
                or ConditionI)             invokes TransformationB
    }
   // @formatter:on

fun main() {
    rules.firstOrNull { it.condition.met() }?.transformation?.run()
}

for (rule in rules) {
    rule.visit(::visitor)
}

class Rule(...) : Element {
    override fun visit(visitor: (Element) -> Unit) {
        condition.visit(visitor)
        transformation.visit(visitor)
        visitor.invoke(this)
    }
}

- condition:
    And:
      a:
        ConditionI: {}
      b:
        ConditionIV: {}
  transformation:
    TransformationA: {}

private val conditions = BasicCondition::class.sealedSubclasses
fun outcomes(): Sequence<Set<ConditionClass>> = sequence {
    for (i in 0L until (1L shl conditions.size)) { // тут возникает 2^N
        val activeConditions = mutableSetOf<ConditionClass>()
        for (j in 0 until conditions.size) {
            if ((i and (1L shl j)) != 0L) {
                activeConditions.add(conditions[j])
            }
        }
        yield(activeConditions)
    }
}

implementation 'com.acme:example:1.0'

implementation ("com.acme:example:1.0")

val jpoint = javaConference {
    //Без круглых скобок нельзя (в отличие от Groovy)
    talk("Пишем приложение на Ktor") deliveredBy {
        speaker("Александр Нозик")
        speaker("Глеб Королькевич")
    }

    talk("One source to rule them all: Kotlin DSL") deliveredBy {
        speaker("Иван Пономарев")
    } withExperts {
        speaker("Андрей Кулешов")
    }
}

val jpoint = javaConference {
    //Всё без скобок (но и без осмысленного имени метода)
    + "Пишем приложение на Ktor" deliveredBy {
        + "Александр Нозик"
        + "Глеб Королькевич"
    }

    + "One source to rule them all: Kotlin DSL") deliveredBy {
        + "Иван Пономарев"
    } withExperts {
        + "Андрей Кулешов"
    }
}

javaConference { //this: ConferenceBuilder
    talk ("Talk 1") deliveredBy {
        //this: ConferenceBuilder.SpeakersBuilder,
        //но также доступны методы из ConferenceBuilder
        talk (...) // ???!!!
    }
}

@DslMarker
annotation class MeetupDsl

@MeetupDsl
class MeetupBuilder { ... }

@MeetupDsl
class SpeakersBuilder { ... }

private val jpoint = javaConference {

    val ip = Speaker("Иван Пономарев", "N/A")

    talk("One source to rule them all: Kotlin DSL") deliveredBy {
        + ip
    } withExperts {
        + Speaker("Андрей Кулешов", "Huawei")
    }

    talk("Kotlin Script: для кого, зачем и как") deliveredBy {
        + Speaker("Анатолий Нечай-Гумен", "Банк «Центр-инвест»")
    } withExperts {
        + ip
    }

}

//ConferenceBuilder
val speakers = mutableMapOf<String, Speaker>()
//Функция возвращает делегат свойства только для чтения
fun speaker(name: String, company: String): ReadOnlyProperty<Nothing?, Speaker> =
    ReadOnlyProperty { _, property ->
        //property.name содержит имя переменной
        speakers.computeIfAbsent(property.name) { Speaker(it, name, company) }
    }

//Сам язык будет гарантировать нам уникальность идентификаторов
val an by speaker("Александр Нозик", "МФТИ")
val gk by speaker("Глеб Королькевич", "Хоум Банк")

talk("Пишем приложение на Ktor") deliveredBy {
    +an
    +gk
}