Is there more cleaner way to achive something like this (template = Spring transaction template)

transactionTemplate.execute {
            val bar = doSomethingTransactional()
            if (bar) {
                { doSomethingOutsideTransaction(bar) }
            } else {
                { doSomethingElseOutsideTransaction() }
            }
        }?.invoke()

So that part of the code is run inside transaction and some part of code is run outside transaction (with data found inside transaction). Example is simplified a lot from real use case so bear with me.. :)

I see that

execute

returns the result of the callback. Can't you just do this?

val bar = transactionTemplate.execute {
  doSomethingTransactional()
}

if (bar) {
  doSomethingOutsideTransaction(bar)
} else {
  doSomethingElseOutsideTransaction()
}

yes but the problem is that non-transactional functions take mixed number of different parameters that then should be all returned from execute, but my simplified example does not show this

Then I would use a sealed class I think. For example:

sealed class BarResult
data class WithBar(bar: Bar) : BarResult
data class WithoutBar(foo: Foo, baz: Baz): BarResult

val res = transactionTemplate.execute {
  val bar = doSomethingTransactional()
  if (bar) WithBar(bar)
  else WithoutBar(foo, baz)
}

when(res) {
 is WithBar -> doSomethingOutsideTransaction(res.bar)
 is WithoutBar -> doSomethingElseOutsideTransaction(res.foo, res.baz)
}

nice 👍