Unresolved reference: T

Question

I need to create a data class:

data class MyClass(val b: Boolean,
               val s: String,
               val flags: Map<Key<T>, T>)

This does not compile due to "Unresolved reference: T"

In the flags map, I need to have Key<String>, String and Key<Int>, Int pairs, but NOT Key<String>, Int

Any ideas on how I can achieve this?

In this case, Key is android.hardware.camera2.CaptureRequest.Key — Mugur, Jul 20 '17 at 12:24

score 4 · Answer 1 · answered Jul 20 '17 at 11:38

4

You must define the generic for the class:

data class MyClass<T>(val b: Boolean,
               val s: String,
               val flags: Map<Key<T>, T>)

answered Jul 20 '17 at 11:38

guenhter

11,255
3
35
66

I feel like that's not going to work. If I'll have MyClass, wouldn't that allow a `Key, Int` pair? – Mugur Jul 20 '17 at 11:50
@Mugur `T` is invariant, so no... Besides, can't you test it? That would only work if you had `flags: Map, T>` – Salem Jul 20 '17 at 12:05

Jorn Vernee · Accepted Answer · 2017-07-20T12:49:10.580

You can't do this directly through the type system, you will have to use encapsulation to ensure the types of key and value are consistent. This problem exists in Java as well.

The solution given by others doesn't work, since you'd only be able to put one type of key/value into the map (the idea of having a Map<Key<T>, T> is somewhat flawed):

val map = mutableMapOf<Key<String>, String>() // what to put as generic params here?
map[Key<String>()] = "blah" // works
map[Key<Int>()] = 3 // doesn't work!
map[Key<Int>()] = "blah" // compiler error (as intended)

or:

val map = mutableMapOf<Key<*>, Any?>()
map[Key<String>()] = "blah" // works
map[Key<Int>()] = 3 // works
map[Key<Int>()] = "blah" // works, but is wrong.

You'd have to for instance write your own encapsulation around a map that ensures a key always matches a value:

class MutableKeyMap {
    private val map = mutableMapOf<Key<*>, Any?>() // private / encapsulated

    operator fun <T> get(key: Key<T>): T {
        return map[key] as T
    }

    operator fun <T> set(key: Key<T>, value: T): Unit { // Key's T must match value's type.
        map[key] = value
    }
}

(You could add an immutable super-interface if you'd like)

And then use that as a field:

data class MyClass(val b: Boolean,
               val s: String,
               val flags: MutableKeyMap)

...

val map = MutableKeyMap()
map[Key<String>()] = "blah" // works
map[Key<Int>()] = 3 // works
map[Key<Int>()] = "blah" // compiler error (as intended)

I've started working on something very similar to what you are suggesting. I'll let you know how it turns out. — Mugur, Jul 20 '17 at 12:52

score 1 · Answer 3 · answered Jul 20 '17 at 11:38

1

You've forgotten about this:

 data class MyClass<T>(val b: Boolean,
 // ----------------^
               val s: String,
               val flags: Map<Key<T>, T>)

For more info: Generics

answered Jul 20 '17 at 11:38

Alex Romanov

11,453
6
48
51

Unresolved reference: T

3 Answers3