осторожно

Supplied types are currently experimental. Everything may be changed a lot.

Kone: Supplied Types

This module provides a way to express types which type arguments can take. The main use case of the module is a foundation for type-safe registry's polymorphic keys.

Applying the dependencies

Gradle Kotlin DSL

build.gradle.kts

dependencies {
    implementation("dev.lounres:kone.suppliedTypes:0.0.0-experiment")
}

Gradle Groovy DSL

build.gradle

dependencies {
    implementation 'dev.lounres:kone.suppliedTypes:0.0.0-experiment'
}

Maven

pom.xml

<dependency>
    <groupId>dev.lounres</groupId>
    <artifactId>kone.suppliedTypes</artifactId>
    <version>0.0.0-experiment</version>
</dependency>

Description

Sometimes (in very, very rare times) you need to distinguish different types that are the same erased types. Like List<Int> and List<String>. Or List<Int> and List<*>. But there is no way to get those types in both compile-time and run-time. In compile-time it's NP-complete problem and in run-time the types are erased. So the only way is to store the types yourself.

Thus, this module introduces "supplied types". They are usual type expressions that are passed along with their object representations. The representations are called "type suppliers".

For example, you have usual class

class Fraction<T>(val numerator: T, val denominator: T)

and you want to associate different types with fractions of their types. It's a strange use case, but let's still consider it. So you create a map like Map<KClass<*>, Fraction<*>> where each Fraction<T> instance can be accessed via KClass<T> instance. But List<Int> and List<Long> are represented as the same keys. OK, let's use KTypes instead. But the problem is the same: in a code like

fun <T> foo() {
    println(typeOf<List<T>>())
}

just List<T> will be printed because T will be erased, so there is no difference between foo<Int>() and foo<Long>().

Thus, we have to manually pass the representation as an argument of function/constructor. Like in the following snippet:

fun <T> foo(tSupplier: SuppliedType<T>) {
    println(
        SuppliedType.Regular<List<T>>(
            kClass = List::class,
            typeArguments = listOf(
                SuppliedProjection.Regular(
                    variance = KVariance.INVARIANT,
                    type = tSupplier,
                )
            ),
            isNullable = false,
        )
    )
}

See SuppliedType and SuppliedProjection references.

Yeah, the manual type supplier construction is cumbersome. So there is a plan to make a compiler plugin that will create such code from

fun <@Supplied T> foo() {
    println(suppliedTypeOf<List<T>>())
}