Avoid capturing `this` when serializing functions in Scala - scala

Question

When serializing functions in Scala, we should take care not to capture fields that are not serializable.
class Foo(s: Set[Int] = Set(1,2,3)) {
def replicate(): () => Foo = () => new Foo(s)
}
val foo = new Foo()
val fn = foo.replicate()
serialize(fn) // java.io.NotSerializableException: Foo
In the above code snippet serializing msg will fail because the function captures this and Foo is not serializable.
To avoid capturing this SIP-21 proposes spores for Scala.
Unfortunately, spores only exist for Scala 2.11.x (see this note).
Luckily, I found in this tread (this is also described in SIP-21) that one can avoid capturing the this reference, by manually creating local values as shown in the code snippet below.
class Foo(s: Set[Int] = Set(1,2,3)) {
def replicate(): () => Foo = {
() => {
{
val localS = this.s
new Foo(localS)
}
}
}
}
Unfortunately, in Scala 2.13.1 this does not work and still captures this (try out the complete code snippet below).
Hence, we cannot serialize the function returned by the replicate method.
Now, I found the following workaround, but it's a rather ugly one.
class Foo(s: Set[Int] = Set(1,2,3)) {
def indirection() = replicate(s)
def replicate(set: Set[Int]): () => Foo = () => new Foo(set)
}
val foo = new Foo()
val msg = foo.indirection()
toStr(msg) // Works :)
By adding an extra indirection, we avoid capturing this and we can serialize the function without requiring Foo to be serializable. However, I don't want to introduce these extra indirections in all the objects I want to serialize this way. How can I avoid this (in Scala 2.13.1) ?
The complete code snippet:
// Start writing your ScalaFiddle code here
import java.io._
import java.util.Base64
def serialize(o: Any) = {
val baos = new ByteArrayOutputStream();
val oos = new ObjectOutputStream( baos );
oos.writeObject( o );
oos.close();
Base64.getEncoder().encodeToString(baos.toByteArray())
}
def deserialize(s: String) = {
val data = Base64.getDecoder().decode( s );
val ois = new ObjectInputStream(new ByteArrayInputStream( data ) );
val o = ois.readObject();
ois.close();
o
}
//////////// TRY 1
try {
class Foo(val s: Set[Int] = Set(1,2,3)) {
def replicate(): () => Foo = () => new Foo(s)
}
val foo = new Foo()
val msg = foo.replicate()
val str = serialize(msg)
val reconstructedFoo = deserialize(str).asInstanceOf[() => Foo]()
println(s"Try 1: success, reconstructedFoo.s = ${reconstructedFoo.s}")
} catch {
case e: NotSerializableException => println("TRY 1: Not serializable.")
}
//////////// TRY 2
try {
class Foo(val s: Set[Int] = Set(1,2,3)) {
def replicate(): () => Foo = {
() => {
{
val localS = this.s
new Foo(localS)
}
}
}
}
val foo = new Foo()
val msg = foo.replicate()
val str = serialize(msg)
val reconstructedFoo = deserialize(str).asInstanceOf[() => Foo]()
println(s"Try 2: success, reconstructedFoo.s = ${reconstructedFoo.s}")
} catch {
case e: NotSerializableException => println("TRY 2: Not serializable.")
}
//////////// Solution (ugly)
try {
class Foo(val s: Set[Int] = Set(1,2,3)) {
def indirection() = replicate(s)
def replicate(set: Set[Int]): () => Foo = () => new Foo(set)
}
val foo = new Foo()
val msg = foo.indirection()
val str = serialize(msg)
val reconstructedFoo = deserialize(str).asInstanceOf[() => Foo]()
println(s"Try 3: success, reconstructedFoo.s = ${reconstructedFoo.s}")
} catch {
case e: NotSerializableException => println("TRY 3: Not serializable.")
}