Thanks for the nice presentation of Scala & Spring playing in concert.

On slide 39 you describe how transactions could be imposed on code blocks via currying and implicit conversions. You mention that it is not possible to make a whole class transactional, but that's not true. You just have to use some more of Scala powerful concepts, i.e. implicit parameters and values in this case.

Look at the following modification:

scala> class Foo {
| def bar[A](block: => A)(implicit tx: Boolean = false): A = {
| println(tx) // Transaction magic happens here ...
| block
| }
| }
defined class Foo

Now you can call bar without tx:

scala> foo.bar(1)
false
res0: Int = 1

Or with explicit tx:

scala> foo.bar(1)(true)
false
res0: Int = 1

And you could define an implicit value for the tx in the class:

scala> class Foo {
| implicit val defaultTx = true
| def bar[A](block: => A)(implicit tx: Boolean = false): A = {
| println(tx) // Transaction magic happens here ...
| block
| }
| }
defined class Foo

Then all methods defined like bar will be transactional by default:

scala> class Foo {
| implicit val defaultTx = true
| def bar[A](block: => A)(implicit tx: Boolean = false): A = {
| println(tx)
| block
| }
| }
defined class Foo

scala> val foo = new Foo
foo: Foo = Foo@6d347991

scala> foo.bar(1)
true
res6: Int = 1
 

Thanks for the nice presentation of Scala & Spring playing in concert.

On slide 39 you describe how transactions could be imposed on code blocks via currying and implicit conversions. You mention that it is not possible to make a whole class transactional, but that's not true. You just have to use some more of Scala powerful concepts, i.e. implicit parameters and values in this case.

Look at the following modification:

scala> class Foo {
| def bar[A](block: => A)(implicit tx: Boolean = false): A = {
| println(tx) // Transaction magic happens here ...
| block
| }
| }
defined class Foo

Now you can call bar without tx:

scala> foo.bar(1)
false
res0: Int = 1

Or with explicit tx:

scala> foo.bar(1)(true)
false
res0: Int = 1

And you could define an implicit value for the tx in the class:

scala> class Foo {
| implicit val defaultTx = true
| def bar[A](block: => A)(implicit tx: Boolean = false): A = {
| println(tx) // Transaction magic happens here ...
| block
| }
| }
defined class Foo

Then all methods defined like bar will be transactional by default:

scala> class Foo {
| implicit val defaultTx = true
| def bar[A](block: => A)(implicit tx: Boolean = false): A = {
| println(tx)
| block
| }
| }
defined class Foo

scala> val foo = new Foo
foo: Foo = Foo@6d347991

scala> foo.bar(1)
true
res6: Int = 1
 

Hi Heiko,

thanks for the feedback!

If you look at Spring Tx support with Spring AOP and annotations you can use

class CustomerDAO {
@Transactional
def aMethod() = {}
}

This is very similar to the higher order function Scala provides:

class CustomerDAO {
@Transactional
def aMethod() = transactional() {}
}

What I am missing is an equivalent to

@Transactional
class CustomerDAO {
def aMethod() = {}
}

This way each method is transactional and there is no impact on the code of the methods. The solution you are suggesting would still need modifications to each method.
 

Hi Eberhard,

I was misinterpreting your slides, thought you wanted to set a certain propagation value once for all methods. This could easily be achieved using an implicit value which is the equivalent to Spring's class level annotation.

But of course you are right: You still need to wrap your method implementations in the transactional-call.

Heiko