implementation("me.jason5lee:defer:1.0.1")

deferScope {
    val f1 = File("/path/to/read-file").bufferedReader()
    deferClosing(f1)
    val f2 = File("/path/to/write-file").bufferedWriter()
        .also { deferClosing(it) }
    defer { println("Closing file ...") }
    // Operating f1 and f2
}

File("/path/to/read-file").bufferedReader().use { f1 ->
    File("/path/to/write-file").bufferedWriter().use { f2 ->
        try {
            // Operating f1 and f2, with 3 indents instead of 1.
        } finally {
            println("Closing file ...")
        }
    }
}

data class Message(val type: String, ...)

class OutputTarget(name: String): Closeable {
    override fun close() { ... }
    fun output(message: Message) { ... }
}

class Output(vararg names: String) : Closeable {
    private val outputMap: Map<String, OutputTarget>

    init {
        outputMap = deferScope {
            val outMap = HashMap<String, OutputTarget>(names.size)

            for (name in names) {
                val target = OutputTarget(name)
                // This defer is to close the created target when an exception is thrown
                deferClosing(target)
                outMap[name] = target
            }
            outMap.toMap().also {
                cancelDefers() // cancel all defers because the construction was successful.
            }
        }
    }

    fun output(message: Message) {
        outputMap[message.type]?.output(message)
    }

    override fun close() {
        // You can use deferScope to ensure all targets are closed even if some fail.
        deferScope {
            for (output in outputMap.values) {
                deferClosing(output)
            }
        }
    }
}