Simple wrapper function combinator engine for Kotlin

Wrapper.kt

// ============ test functions ============

fun withTransactional() = transactional {
    println("withTransactional body")
}

fun withLogged() = logged {
    println("withLogged body")
}

fun foo() = (logged + transactional) {
    println("foo body")   
}

fun main() {
    withTransactional()
    withLogged()
    foo()
}  
    
// ============ wrappers ============

val transactional = wrapper {
    println("before transational")
    try { it() } finally { 
        println("after transactional")
    }
}

val logged = wrapper {
    println("before logged")
    try { it() } finally {
        println("after logged")
    }
}

// ============ engine impl ============

fun wrapper(impl: (() -> Unit) -> Unit): Wrapper = object : Wrapper() {
    override fun impl(it: () -> Unit) = impl(it)
}


abstract class Wrapper {
    abstract fun impl(it: () -> Unit)
    
    operator fun <R> invoke(body: () -> R): R {
        var result: R? = null
        impl { result = body() }
        @Suppress("UNCHECKED_CAST")
        return result as R
    }
    
    operator fun plus(other: Wrapper) = wrapper {
        impl {
            other.impl { it() }
        }
    }
}