Copy translations

[pablisco]

There is a use case that could help. Although I'm not sure if it falls outside this library's scope.

Let's say we have a type definition like this (potentially on different modules):

// common
interface Person {
  val name: String
  val age: Int
}
// persistence
@Entity
data class LocalPerson(override val name: String, override val age: Int): Person

// Network
@Serializable
data class RemotePerson(override val name: String, override val age: Int): Person

This is a good pattern to separate concerns without leaking external dependencies (in this case Room and kotlinx-serialization)

If we want to convert from and to another, we must create 'from' and 'to' functions. It's a lot of boilerplate.

So, generating these converter functions would be relatively painless.

We could pick up any data class that has an interface (or more) and generate the converter functions (copyToLocalPerson()?)

The other thing for this is that we also need to create a plain type for the interface so we can convert to that type from the subtypes.

[pablisco]

Actually, we probably don't need to generate the synthetic class for the interface. As, they are already that type, duh 😬

[pablisco]

These are some examples of what we can generate:

fun People.copyToLocalPerson(): LocalPerson =
  LocalPerson(name = name, age = age)

fun People.copyToRemotePerson(): RemotePerson =
  RemotePerson(name = name, age = age)

Or, we could make them aliases of copy and copyMap with the final result being on a given of the desired type. Maybe something like copyAsLocalType

Use case:

class PeopleRepository {

  suspend fun itsbirthdayTime(person: Person) = 
    database.save(person.copyAsLocalPerson { age++ })

}

Or, in some future:

context(PeopleScope)
fun Person.itsbirthdayTime() = database.save(person.copyAsLocalPerson { age++ })

[serras]

Here's another idea: generate a from method which takes the interface as argument, and generates a concrete class. This only works when the concrete class "fully implements" the interface, like Person above. In this case this would look:

fun LocalPerson.Companion.from(p: Person) = LocalPerson(...)
fun RemotePerson.Companion.from(p: Person) = RemotePerson(...)

so you would be able to translate one to the other by doing LocalPerson.from(remotePerson).

What I like about this approach is that it makes clear that the copying "belongs" to LocalPerson and RemotePerson. With the approach above, it seems that they "belong" to Person, which is not the case.

[pablisco]

That's a good point, regarding ownership. The only problem with that approach is that it requires a companion object. I'm a big fan of top-level factory functions instead:

fun LocalPerson(p: Person) = LocalPerson(...)
fun RemotePerson(p: Person) = RemotePerson(...)

These are contemplated on Kotlin's coding conventions too (in case it feels odd hehe)
https://kotlinlang.org/docs/coding-conventions.html#function-names

[serras]

I like this solution. We've had problems in the past with companion objects not existing in Arrow Optics, and I think this works around the problem neatly.