Why does this extension function not call `Spannab...

# getting-started

[Mark]

Why does this extension function not call SpannableStringBuilder.inSpans()

fun <A : Appendable> A.inSpans(vararg spans: Any, builderAction: A.() -> Unit): A =
    if (this is SpannableStringBuilder) {
       // PROBLEM: doesn't call SpannableStringBuilder.inSpans()
       inSpans(spans = spans, builderAction = builderAction) 
    } else {
        builderAction()
        this
    }

[Mark]

I was able to fix by changing to:

fun <A : Appendable> A.inSpans(vararg spans: Any, builderAction: A.() -> Unit): A {
    if (this is SpannableStringBuilder) {
        inSpans(spans) {
            builderAction()
        }
    } else {
        builderAction()
    }
    return this
}

It seems the key part is to specify the lambda explicitly rather than passing the builderAction reference

[ephemient]

because builderAction: A.() -> Unit so overload resolution can only choose your local function. when wrapped in the lambda, the receiver it's being called on is the outer A, not the inner SpannableStringBuilder

[ephemient]

also in your second variant, if you're not writing spans = spans or *spans, you're invoking the span = overload

[Mark]

That spans = spans issue is a nasty one (IMO an API design flaw). I actually had it like that originally, but mistakenly forgot about the easy-to-make mistake.

[Mark]

Are you saying the lambda should be (this as A).builderAction()?

[ephemient]

no, I'm saying that when you write { builderAction() } it actually means { [e-mail]() }, not { this.builderAction() } - that's what makes it different than passing it directly

[Mark]

Have you got those the wrong way around? In this case don’t we want { this.builderAction() } ?

[ephemient]

you want that but you can't have it because this: SpannableStringBuilder does not match builderAction: A.() -> Unit

[ephemient]

so your lambda is silently not behaving as you seem to expect

[ephemient]

if you changed it to builderAction: Appendable.() -> Unit it would be applicable

[Mark]

Okay, so that would be a good solution, but (this as A). would also work right?

[ephemient]

it's potentially unsafe: A could be a subtype of SpannableStringBuilder

[ephemient]

(there aren't any by default, but it's not a final class)

[ephemient]

in other words, this is SpannableStringBuilder does not imply <SpannableStringBuilder : A>