И не будет

Keep-176

Посмоооотрим

Костыль есть -  делается класс обертка и там мембер экстеншен

Скорее нет, чем да. Т.е. есть два обходных пути:
1. Экстеншн функция лежит в одном из нужных классов (class A { fun B.foo() { } })
2. Очень хитро создавать контексты, чтобы создавать композитный контекст, который отнаследуется от двух обычных

Но да, прямое решение проблемы - KEEP-176.

Можно еще делать вложенные контексты, но это не решает проблему сигнатуры функции с двумя экстеншенами

а если оба класса нельзя менять? если я правильно понял

что под контекстами имеется ввиду?

Тогда никак. Только делать обертки.

Есть ещё каррирование екстеншен лямбд. Что-то типа:

fun String.foo(): Double.() -> Int.() -> String = dbl@ { { "${this@foo} ${this@dbl} $this" } }
fun main() {
    println("bar".foo().let { 2.0.it() }.let { 1.it() })
    println("baz".foo()(3.2)(2))
}

Ну в общем случае просто класс.

Идея очень грубо такая (могу местами наврать, но суть вроде похожа)

interface A //and some impl
interface B //and some impl
class Composite(val a: A, val b: B): A by a, B by b

fun A.withCompositeContext(B b, action: Composite.() -> Unit) = Composite(this, b).run(::action)

Тогда экстеншны можно навешивать на композитный тип

interface A //and some impl
interface B //and some impl
class Composite(val a: A, val b: B): A by a, B by b

fun A.withCompositeContext(B b, action: Composite.() -> Unit) = Composite(this, b).run(::action)

Выглядит круто, поиграюсь, спасиб

fun String.foo(): Double.() -> Int.() -> String = dbl@ { { "${this@foo} ${this@dbl} $this" } }
fun main() {
    println("bar".foo().let { 2.0.it() }.let { 1.it() })
    println("baz".foo()(3.2)(2))
}

выглядит чуть жутковато

Ну это потому, что тут приходится this@... писать, чтобы получить конкретный ресивер. Сейчас получше пример сделаю

fun String.foo(): Double.() -> Int.() -> String = dbl@ { { "${this@foo} ${this@dbl} $this" } }
fun main() {
    println("bar".foo().let { 2.0.it() }.let { 1.it() })
    println("baz".foo()(3.2)(2))
}

Но идея довольно крутая, лямбда из лямбды

Можно ещё так:

class A(val a: String)
class B(val b: String)
class C(val c: String)

fun A.abc(): B.() -> C.() -> String = { { "$a $b $c" } }

fun main() {
    println(A("a").abc().let { B("b").it() }.let { C("c").it() })
    println(C("c").(B("b").(A("a").abc())())())
    println(A("a").abc()(B("b"))(C("c")))
}

А самая интересная часть в каррированном представлении, что такую функцию можно применять только к части параметров, то есть A("a").abc() - вполне корректное выражение, как и A("a").abc()(B("b"))

А есть что-нибудь готовое для раскаррирования?)

Это тупо нагенерить подобных функций: fun <A, B, C> ((A) -> (B) -> C).uncurry(): (A, B) -> C = { a, b -> this(a)(b) }

В стрелке может быть, надо глянуть