Why is it necessary to have a `Observer` prefix in...

# getting-started

[Martin Nordholts]

Why is it necessary to have a Observer prefix in the second line below in order for SAM conversion to work, but not in the first line? The last parameter has identical declarations in these two cases.

MutableLiveData<String>().observeForever({  })        // No 'Observer' prefix necessary
    MutableLiveData<String>().observe(this, Observer {  })        // 'Observer' prefix necessary!

    // Java declarations
    public void observeForever(@NonNull Observer<? super T> observer) {
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {

[ilya.gorbunov]

Currently SAM conversion for a function works by providing a synthetic overload where all SAM interfaces are replaced with the corresponding functional types.

Looks like LifecycleOwner is also a SAM interface, so we've got two overloads here: the original one, where both owner and observer are interfaces, and the synthetic one, where both owner and observer are functional types. Passing this instance to owner selects the origninal one, so you have to pass observer not as a function, but as an interface either.

[Martin Nordholts]

Thanks for explaining, but I don’t fully understand your answer and would like to learn more, but https://kotlinlang.org/docs/reference/java-interop.html#sam-conversions didn’t quite help me out here. For example, I wonder what “synthetic overload” is.

Is there somewhere I can read more about this?

[Martin Nordholts]

Or doyou mean synthetic method overload on MutableLiveData? I.e. that the compiler pretends that there is a version of observe that takes proper Kotlin functions as arguments?

[ilya.gorbunov]

Yes, it's an overload of observe function. For example like here:

[Martin Nordholts]

Aha now I think I get it.

Couldn’t the compiler make 3 synthetic overloads in this case then? I.e.

observe(interface, interface)
observe(function, function)
observe(function, interface)
observe(interface, function)?

Although I guess that’s O(n^2)-ish… But in practice it should work most of the time probably.

[ilya.gorbunov]

More likely O(2^n)-ish, which is much worse

[Martin Nordholts]

Yes you’re right, it would be O(2^n)-ish

[Martin Nordholts]

Anyway, now I fully understand what happens. Thanks a lot for explaining.

[ilya.gorbunov]

AFAIK, the new inference has another approach to this that doesn't rely on synthetic overloads and allows to apply the conversion to an each argument individually.