Lambda en expresión de object de tipo múltiple

Me dieron una class Foo que hace un poco de work() :

 open class Foo() { fun work(x: T) { // Effects taking place here } } 

Y también estoy provisto (pero por otra persona) de un método useJob() que consume un object de interfaz tipo Bar tiene un solo método doJob() .

 fun useJob(bar: Bar) interface Bar { fun doJob(x: T) } 

Resulta que Foo.work() hace el trabajo esperado por useJob() . Sin embargo, para poder useJob() work() invocación de useJob() work() , necesito escribir algo así:

 useJob(object : Foo(), Bar { fun doJob(x: T) { work(x) } }) 

¿Hay alguna forma de usar una lambda en lugar de esta gota?

EDITAR: el comentario de @jrtapsell me hizo darme count de que Foo está realmente abierto.

Si Bar se definió en Java, podría escribir

 useJob { Foo().work(x) } 

o

 val foo = Foo() useJob { foo.work(x) } 

para evitar build Foo() todo el time en caso de que useJob invoque su argumento varias veces.

Pero

tenga en count que esta característica solo funciona para la interoperabilidad de Java; como Kotlin tiene types de funciones adecuados, la conversión automática de funciones en implementaciones de las interfaces de Kotlin es innecesaria y, por lo tanto, no está soportada.

Sin mover Bar a Java, elegiría la solución de joecks o definiría una sobrecarga de useJob (posiblemente como método de extensión). Lo que es mejor depende de cuántos methods como useJob tenga y cuántos usos para cada uno.

Bueno, la forma más fácil de lograr esto sería mediante el uso de un método de fábrica que crea una instancia de Bar y acepta una llamada de function:

 fun job(func: (Param) -> Unit) : Bar = object: Bar { override fun doJob(x: Param) = func(x) } 

entonces puedes usar

 useJob( job { Foo().work(it) } ) 

Es un problema, que useJob espera una interfaz en lugar de un tipo de function directamente. De esta manera solo puedes hacer:

 val bar = object : Bar { override fun doJob(x: String) = Foo().work(x) } useJob(bar) 

Podrías hacerlo así:

 // Mock class class Param // Provided code open class Foo<T> { fun work(x: T) { // Effects taking place here } } fun useJob(bar: Bar) {} interface Bar { fun doJob(x: Param) } // New code object FooBar: Foo<Param>(), Bar { override fun doJob(x: Param) = work(x) fun use() = useJob(this) } fun x() { FooBar.use() } 

Requiere un poco más de código para el object FooBar, pero limpia los sitios de llamadas.