interface FooProvider {
    fun <T> getFoo() : T <--- works
    val <T> foo: T <--- doesnt
}

fun <T> findViewById(): T

interface FooProvider<T> {
    fun getFoo(): T// <--- works
    val foo2: T //<--- works
}

val

override val appComponent: AppComponent
        get() = ...

val

val foo: Foo get() = ...

val <T> foo: T get() = ...

()

fooProvider.foo<SomeFoo> vs fooProvider.foo<SomeFoo>()

val <T> foo: T

override val appComponent: AppComponent
        get() = ...

<T>

T

foo

T

as T

fooProvider.foo<String>

fooProvider.foo<SomeFoo>

fooProvider.foo as SomeFoo

()

foo()

T

getFoo()

getX()

They hold true where you expect properties to be data

fooProvider.<SomeView>foo

fooProvider.<String>foo

doSomehtingAndReportSuccess(): Boolean

val nameObservable = ObservableValue("name")
var name
    get() = nameObservable.get()
    set(value) = nameObservable.set(value)

name

40 72 75 63 6b 75 73 74 62 6f 6f 6d 20 79 65 73 2c 20 70 72 65 63 69 73 65 6c 79

you cannot argue about anything, if no axiomatic baseline is established

class Bounds(
    var minX: Double,
    var maxX: Double,
    var minY: Double,
    var maxY: Double
) {
    var width: Double
        get() = maxX - minX
        set(value) {
            maxX = minX + value
        }
    // Same idea for height
}

width

Bounds

Bounds

width

you almost had me at...

val foo: T
 get() = whatever as T

the problem is wrong if it yields uncertain answers

fooProvider.usingFoo { Int it -> it * 5 }

getById

T