class NboAdapter(
    val idAdapter: ColumnAdapter<NboId, String>
    ...
}

val nboAdapter = NboAdapter(
	idAdapter = IdColumnAdapter(::NboId), <--------------- do away with ::NboId
    ...
)

class IdColumnAdapter<T : Id>(val factory: (String) -> T) : ColumnAdapter<T, String> {
    override fun decode(databaseValue: String): T = factory(databaseValue)
    override fun encode(value: T): String = value.value
}

interface Id : Comparable<Id> {
    val value: String
    override fun compareTo(other: Id): Int = value.compareTo(other.value)
}

data class NboId(override val value: String) : Id

is there a way to infer the

::NboId

constructor? I'm trying maybe with reified but that would require

T(value)

constructor which is not possible in kotlin/java without reflection, right? however this does exist

inline fun <reified T : Enum<T>> EnumColumnAdapter(): EnumColumnAdapter<T> {
  return EnumColumnAdapter(enumValues())
}

is that some sort of magic? I thought

values

was only definied on the concrete enum

It is somewhat magic, as it's implemented as a compiler intrinsic

okay so I'm out of luck?

I don't believe there is a way to infer a constructor of a reified type unfortunately without reflection

that kinda melts my brain 😄

Don’t think so either unfortunately, at once point was hoping there could be something like a

Valued<T>

interface that value classes would automatically implement that would allow for generic destructuring of them

EXACTLY, same as the enum magic