Lets say I have this ```class Preference<T : Any> private constructor( val key: String...

# announcements

[jaqxues]

Lets say I have this

class Preference<T : Any> private constructor(
        val key: String,
        val default: T,
        val type: KClass<T>
)

// Extension Function
fun getPref(): T { // This should be a nullable generic set by the preference
    // parse and return pref
}

Now, not every preference is not-null. So how can I omit <T: Any> to get to <T> so the preference itself can set itself nullable only via its type generic?
The problem is that KClass does not like <T> and requires <T: Any>

is there any smart way to get a not-null type generic from a nullable one? Or a reified function way to handle that?

[Michael de Kaste]

Isn't this just what you mean?

class Preference<T : Any> private constructor (
        val key: String,
        val default: T?,
        val type: KClass<T>
    )

[Luca Clemente Gonzalez]

If getPref will never return null, it’s ok the way you have it

[jaqxues]

No, then I would have to make getPref() nullable for every preference. I want to let the Pref itself decide if its nullable

val notNull: Preference<String>...
val nullablle: Preference<String?>...

so basically T, which is defined here above should be used in getPref to decide whether the preference is nullable or notnull

[jaqxues]

Well I want getPref to be nullable for some prefs

[Luca Clemente Gonzalez]

you can declare the same function and just make one nullable

[jaqxues]

that would not let the Preference type decide if its nullable, but the caller site

[Luca Clemente Gonzalez]

but you will have trouble importing this. It will have to take one and it will not check first if it’s null and then decide for you which one

[Luca Clemente Gonzalez]

I would do one function that checks for the nullability of T

[Luca Clemente Gonzalez]

if it’s null you call a private function getPrefNull and if it’s not null you call a private function getPrefNotNull

[jaqxues]

that wouldnt solve compiler warnings etc

[Luca Clemente Gonzalez]

Assuming both return the same stuff

[jaqxues]

the compiler would still yell at you "nullable"

[jaqxues]

fun doThis(): T? = ...
fun doThat(): T = ...

DecideThisThat would now have to return a nullable type

fun decideThisThat(): T? = if (nullable) doThis() else doThat()

[Luca Clemente Gonzalez]

what will you return if T is null?

[jaqxues]

class Preference<T> private constructor(
        val key: String,
        val default: T,
        val type: KClass<T!>
)
// Extension Function
fun getPref(): T { // This should be a nullable generic set by the preference
    // parse and return pref
}

Basically this is what i want:
• T is nullable and default is nullable
• getPref now uses null-safe type generics (nullable if T of pref is nullable)
• KClass doesnt cry about a nullable generic
Problem: you cant just make T!

[jaqxues]

I think i could just make KClass<T> KClass<*>, but i want that type safety

[Michael de Kaste]

you can't have a constructor accepting both a nullable and non-nullable type and then define a function that only returns the non-nullable type.

You simply don't know whether the value within preference is nullable or not. And since returning T? encapsulates T you have to go for T? on the getPref() function

[jaqxues]

hm not really, no

[jaqxues]

class Data<T>(val data: T)

fun <T> Data<T>.get(): T = data

fun main() {
    val example = Data<String?>("Hello")
    example.data
    val example2 = Data("Hello")
    example2.data
}

[jaqxues]

example.get() is nullable, example2.get() is not null

the nullability is defined by the type generic in the constructor

[jaqxues]

It is a very complex problem, I know

[jaqxues]

so the problem is KClass does not like nullable T, it wants T: Any

and I do not want to erase that type generic there since it will break stuff

[Kroppeb]

There isn't a way to do this, it's something that bothers me too

[cristiangm]

IMHO you always can create the NullablePreference and Preference, both having the method you want, and create a Factory if you want to hide the 2 classes.

If it needs to be an extension function because you can't change Preference....
Isn't possible to do:
Preference<T>.getPref() : T
Preference<T?>.getPref(): T?