One Source to Rule Them All

fun main() {
    if (conditionOneMet() && conditionTwoMet()) {
        runTransformationA()
    } else if ((ConditionThreeMet() || ConditionFourMet()) && 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(
    val condition: Condition,
    val transformation: Transformation) : 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)) { // this is where 2^N emerges
        val activeConditions = mutableSetOf<ConditionClass>()
        for (j in 0 until conditions.size) {
            if ((i and (1L shl j)) != 0L) {
                activeConditions.add(conditions[j])
            }
        }
        yield(activeConditions)
    }
}

// Extension point in the builder
fun customCondition(lambda: () -> Boolean): Condition =
    Condition(lambda)

// Using the extension point
customCondition { Random.nextDouble() < .88} invokes TransformationC


// Some other DSL
customBusinessRule { checkSmthProgramatically() }

implementation 'com.acme:example:1.0'

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

val ndcCopenhagen = conference {
    //Cannot be called without parentheses (unlike Groovy)
    session("Edge-native applications - what happened to cloud-native?") deliveredBy {
        speaker("Mikkel Mørk Hegnhøj")
        speaker("Thorsten Hans")
    } inRoom ("Room 3")

    session("One Source to Rule Them All: Kotlin DSLs") deliveredBy {
        speaker("Ivan Ponomarev")
    //May be called without (..) -- infix fun
    } inRoom "Room 3"
}

val ndcCopenhagen = conference {
    + "Edge-native applications - what happened to cloud-native?" deliveredBy {
        + "Mikkel Mørk Hegnhøj"
        + "Thorsten Hans"
    } inRoom "Room 3"

    + "One Source to Rule Them All: Kotlin DSLs" deliveredBy {
        + "Ivan Ponomarev"
    } inRoom "Room 3"
}

conference { //this: ConferenceBuilder
    session ("Session 1") deliveredBy {
        //this: ConferenceBuilder.SpeakersBuilder,
        //but methods from ConferenceBuilder are also available
        session (...) // ???!!!
    }
}

@DslMarker
annotation class ConferenceDsl

@ConferenceDsl
class ConferenceBuilder { ... }

@ConferenceDsl
class SpeakersBuilder { ... }

val ndcCopenhagen = conference {
    val ip by speaker("Ivan Ponomarev", "Synthesized")
    val mj by speaker("Mark Jervelund", "Microsoft")

    session("One Source to Rule Them All: Kotlin DSLs") deliveredBy {
        +ip
    } inRoom "Room 6"
    session("Part 1/2: Introduction to capture the flag (CTF)") deliveredBy {
        +mj
    } inRoom "Room 4"
    session("Part 2/2: Introduction to capture the flag (CTF)") deliveredBy {
        +mj
    } inRoom "Room 4"
}

//ConferenceBuilder
val speakers = mutableMapOf<String, Speaker>()
//The function returns a delegate for a read-only property
fun speaker(name: String, company: String): ReadOnlyProperty<Nothing?, Speaker> =
    ReadOnlyProperty { _, property ->
        //property.name contains the variable's name
        speakers.computeIfAbsent(property.name) { Speaker(it, name, company) }
    }

//The language syntax itself will ensure the uniqueness of identifiers
val mmh by speaker("Mikkel Mørk Hegnhøj", "Fermyon")
val th by speaker("Thorsten Hans", "Fermyon")

session("Edge-native applications - what happened to cloud-native?") deliveredBy {
        +mmh
        +th
    } inRoom "Room 3"

fun verb(action: EntityBuilder.()->Unit) {
   val builder = EntityBuilder()
   builder.action()
   ...
}

object conference {
   //The default method with a lambda parameter
    operator fun invoke(action: ConferenceBuilder.() -> Unit): List<Talk> {
val builder = ConferenceBuilder()
builder.action()
return builder.talks;
}
    //additional properties
    var name: String = ""
}