Aspect operators

AspectOperators.kt

// Aspect interface for combinator
interface Aspect {
    operator fun <R> invoke(block: () -> R): R
}

// Aspect combinator
operator fun Aspect.plus(other: Aspect) = object : Aspect {
    override fun <R> invoke(block: () -> R): R =
        this@plus {
            other {
                block()
            }
        }
}

// inline version of logged aspect
inline fun <R> logged(block: () -> R): R {
    println("Logged before")
    return try {
        block()
    } finally {
        println("Logged after")
    }
}

// functional version of logged aspect for combinator
val logged = object : Aspect {
    override fun <R> invoke(block: () -> R): R = logged(block)
}

// inline version of transactional aspect
inline fun <R> transactional(block: () -> R): R {
    println("Transactional before")
    return try {
        block()
    } finally {
        println("Transactional after")
    }
}

// functional version of transactional aspect for combinator
val transactional = object : Aspect {
    override fun <R> invoke(block: () -> R): R {
        return transactional(block)
    }
}

// --- test code --

fun testLogged() = logged {
    println("testLogged")
}

fun testTransactional() = transactional {
    println("testTransactional")
}

fun testBoth() = (logged + transactional) {
    println("testBoth")
}

fun main() {
    testLogged()
    testTransactional()
    testBoth()
}