Kotlinのシールドクラスを活用したDSL設計手法を徹底解説

sealed class Shape {
    data class Circle(val radius: Double) : Shape()
    data class Rectangle(val width: Double, val height: Double) : Shape()
}

   fun describeShape(shape: Shape): String = when (shape) {
       is Shape.Circle -> "Circle with radius ${shape.radius}"
       is Shape.Rectangle -> "Rectangle with width ${shape.width} and height ${shape.height}"
   }

   html {
       body {
           h1 { "Hello, DSL!" }
           p { "This is a simple example of DSL." }
       }
   }

form {
    input("text") {
        placeholder = "Enter your name"
    }
    button {
        text = "Submit"
    }
}

sealed class FieldType {
    object Text : FieldType()
    object Number : FieldType()
}

fun formField(type: FieldType, value: Any): String = when (type) {
    FieldType.Text -> "Text field with value: $value"
    FieldType.Number -> "Number field with value: $value"
}

sealed class Element {
    data class Input(val type: String, val placeholder: String) : Element()
    data class Button(val text: String) : Element()
}

class FormBuilder {
    private val elements = mutableListOf<Element>()

    fun input(type: String, placeholder: String) {
        elements.add(Element.Input(type, placeholder))
    }

    fun button(text: String) {
        elements.add(Element.Button(text))
    }

    fun build(): List<Element> = elements
}

fun form(init: FormBuilder.() -> Unit): List<Element> {
    val builder = FormBuilder()
    builder.init()
    return builder.build()
}

// 使用例
val formElements = form {
    input("text", "Enter your name")
    button("Submit")
}

sealed class FormElement {
    data class Input(val type: String, val placeholder: String) : FormElement()
    data class Button(val text: String) : FormElement()
}

class FormBuilder {
    private val elements = mutableListOf<FormElement>()

    fun input(type: String, placeholder: String) {
        elements.add(FormElement.Input(type, placeholder))
    }

    fun button(text: String) {
        elements.add(FormElement.Button(text))
    }

    fun build(): List<FormElement> = elements
}

fun form(init: FormBuilder.() -> Unit): List<FormElement> {
    val builder = FormBuilder()
    builder.init()
    return builder.build()
}

val myForm = form {
    input("text", "Enter your name")
    button("Submit")
}

myForm.forEach {
    when (it) {
        is FormElement.Input -> println("Input: type=${it.type}, placeholder=${it.placeholder}")
        is FormElement.Button -> println("Button: text=${it.text}")
    }
}

Input: type=text, placeholder=Enter your name  
Button: text=Submit  

   sealed class InputElement {
       data class TextInput(val placeholder: String) : InputElement()
       data class PasswordInput(val placeholder: String) : InputElement()
   }

   sealed class ActionElement {
       data class Button(val text: String) : ActionElement()
   }

   interface FormElement
   sealed class InputElement : FormElement {
       data class TextInput(val placeholder: String) : InputElement()
   }
   sealed class ActionElement : FormElement {
       data class Button(val text: String) : ActionElement()
   }

   class InputBuilder {
       private val inputs = mutableListOf<FormElement>()
       fun textInput(placeholder: String) {
           inputs.add(FormElement.Input("text", placeholder))
       }
       fun build() = inputs
   }

   class FormBuilder {
       private val elements = mutableListOf<FormElement>()
       fun inputs(init: InputBuilder.() -> Unit) {
           val builder = InputBuilder()
           builder.init()
           elements.addAll(builder.build())
       }
       fun button(text: String) {
           elements.add(FormElement.Button(text))
       }
       fun build() = elements
   }

   fun FormBuilder.defaultForm() {
       input("text", "Default Placeholder")
       button("Submit")
   }

   fun createElement(type: String, placeholder: String): FormElement {
       return when (type) {
           "text" -> FormElement.Input("text", placeholder)
           "password" -> FormElement.Input("password", placeholder)
           else -> throw IllegalArgumentException("Unsupported type")
       }
   }

val form = form {
    input("text", "Enter your name")
    button("Submit")
}

val form = FormBuilder()
form.addInput("text", "Enter your name")
form.addButton("Submit")
form.build()

sealed class FormElement {
    data class Input(val type: String, val placeholder: String) : FormElement()
    data class Button(val text: String) : FormElement()
    // 新しい要素を追加する
    data class Checkbox(val label: String) : FormElement()
}

class FormBuilder {
    private val elements = mutableListOf<FormElement>()

    fun input(type: String, placeholder: String) {
        if (type.isBlank()) throw IllegalArgumentException("Input type cannot be blank")
        elements.add(FormElement.Input(type, placeholder))
    }

    fun build(): List<FormElement> {
        if (elements.isEmpty()) throw IllegalStateException("Form must contain at least one element")
        return elements
    }
}

fun FormBuilder.defaultTextInput() {
    input("text", "Default Placeholder")
}

@Test
fun `should throw exception for empty input type`() {
    val builder = FormBuilder()
    assertThrows<IllegalArgumentException> {
        builder.input("", "Placeholder")
    }
}

sealed class FormElement {
    data class Input(val type: String, val placeholder: String) : FormElement()
    data class Button(val text: String) : FormElement()
}

class FormBuilder {
    private val elements = mutableListOf<FormElement>()

    fun input(type: String, placeholder: String) {
        elements.add(FormElement.Input(type, placeholder))
    }

    fun button(text: String) {
        elements.add(FormElement.Button(text))
    }

    fun build(): List<FormElement> = elements
}

fun form(init: FormBuilder.() -> Unit): List<FormElement> {
    val builder = FormBuilder()
    builder.init()
    return builder.build()
}

val myForm = form {
    input("text", "Enter your name")
    button("Submit")
}

fun main() {
    val myForm = form {
        input("text", "Enter your name")
        button("Submit")
    }

    myForm.forEach {
        when (it) {
            is FormElement.Input -> println("Input: type=${it.type}, placeholder=${it.placeholder}")
            is FormElement.Button -> println("Button: text=${it.text}")
        }
    }
}

Input: type=text, placeholder=Enter your name  
Button: text=Submit  

sealed class FormElement {
    data class Input(val type: String, val placeholder: String) : FormElement()
    data class Button(val text: String) : FormElement()
    data class Checkbox(val label: String) : FormElement()
}

class FormBuilder {
    private val elements = mutableListOf<FormElement>()

    fun input(type: String, placeholder: String) {
        elements.add(FormElement.Input(type, placeholder))
    }

    fun button(text: String) {
        elements.add(FormElement.Button(text))
    }

    fun checkbox(label: String) {
        elements.add(FormElement.Checkbox(label))
    }

    fun build(): List<FormElement> = elements
}

// DSL利用例
val myForm = form {
    input("text", "Enter your name")
    checkbox("I agree to the terms and conditions")
    button("Submit")
}

sealed class Rule {
    data class Condition(val field: String, val operator: String, val value: Any) : Rule()
    data class Action(val name: String, val params: Map<String, Any>) : Rule()
}

class RuleEngineBuilder {
    private val rules = mutableListOf<Pair<Rule.Condition, Rule.Action>>()

    fun rule(condition: Rule.Condition, action: Rule.Action) {
        rules.add(condition to action)
    }

    fun build(): List<Pair<Rule.Condition, Rule.Action>> = rules
}

fun rules(init: RuleEngineBuilder.() -> Unit): List<Pair<Rule.Condition, Rule.Action>> {
    val builder = RuleEngineBuilder()
    builder.init()
    return builder.build()
}

val myRules = rules {
    rule(
        Rule.Condition("age", ">", 18),
        Rule.Action("grantAccess", mapOf("role" to "adult"))
    )
    rule(
        Rule.Condition("age", "<=", 18),
        Rule.Action("denyAccess", mapOf("reason" to "underage"))
    )
}

myRules.forEach { (condition, action) ->
    println("If ${condition.field} ${condition.operator} ${condition.value}, then ${action.name} with ${action.params}")
}

If age > 18, then grantAccess with {role=adult}  
If age <= 18, then denyAccess with {reason=underage}  

sealed class WorkflowStep {
    data class Task(val name: String, val action: () -> Unit) : WorkflowStep()
    data class Decision(val condition: () -> Boolean, val onTrue: WorkflowStep, val onFalse: WorkflowStep) : WorkflowStep()
}

class WorkflowBuilder {
    private val steps = mutableListOf<WorkflowStep>()

    fun task(name: String, action: () -> Unit) {
        steps.add(WorkflowStep.Task(name, action))
    }

    fun decision(condition: () -> Boolean, onTrue: WorkflowBuilder.() -> Unit, onFalse: WorkflowBuilder.() -> Unit) {
        val trueBranch = WorkflowBuilder().apply(onTrue).build()
        val falseBranch = WorkflowBuilder().apply(onFalse).build()
        steps.add(WorkflowStep.Decision(condition, trueBranch.first(), falseBranch.first()))
    }

    fun build(): List<WorkflowStep> = steps
}

fun workflow(init: WorkflowBuilder.() -> Unit): List<WorkflowStep> {
    val builder = WorkflowBuilder()
    builder.init()
    return builder.build()
}

val myWorkflow = workflow {
    task("Start") { println("Starting workflow...") }
    decision(
        condition = { true },
        onTrue = {
            task("Task A") { println("Executing Task A") }
        },
        onFalse = {
            task("Task B") { println("Executing Task B") }
        }
    )
    task("End") { println("Workflow complete.") }
}

myWorkflow.forEach { step ->
    when (step) {
        is WorkflowStep.Task -> {
            println("Executing task: ${step.name}")
            step.action()
        }
        is WorkflowStep.Decision -> {
            println("Evaluating decision...")
            if (step.condition()) step.onTrue else step.onFalse
        }
    }
}

Executing task: Start  
Starting workflow...  
Evaluating decision...  
Executing task: Task A  
Executing Task A  
Executing task: End  
Workflow complete.