Lambda in multiple type object expression

Question

I'm provided a class Foo which does some work():

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

And I am also provided (but by someone else) a method useJob() which consumes an object of interface type Bar having a single method doJob().

fun useJob(bar: Bar)

interface Bar {
    fun doJob(x: T)
}

It turns out Foo.work() does the job expected by useJob(). However, in order to have useJob() calling work(), I need to write something like that:

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

Is there any way to use a lambda instead of this blob?

EDIT: @jrtapsell comment made me realize Foo is actually open.

Do you need the Bar interface, or could you just have fun useJob(bar: (T) -> Unit)? — Ruckus T-Boom
– Ruckus T-Boom, Commented Oct 24, 2017 at 16:21

joecks · Accepted Answer · 2017-10-23 15:47:25Z

4

Well the easiest way to achieve this would be by using a factory method that creates a instance of Bar and accepts a function call:

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

then you can use

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

answered Oct 23, 2017 at 15:47

joecks

4,64740 silver badges52 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Alexey Romanov · Accepted Answer · 2017-10-23 17:31:02Z

1

If Bar were defined in Java, you could write

useJob { Foo().work(x) }

or

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

to avoid constructing Foo() every time in case useJob calls its argument multiple times.

But

note that this feature works only for Java interop; since Kotlin has proper function types, automatic conversion of functions into implementations of Kotlin interfaces is unnecessary and therefore unsupported.

Without moving Bar to Java, I'd go with joecks' solution or define an overload of useJob (possibly as extension method). Which is better depends on how many methods like useJob you have and how many uses for each.

answered Oct 23, 2017 at 17:31

Alexey Romanov

172k38 gold badges329 silver badges509 bronze badges

Comments

s1m0nw1 · Accepted Answer · 2017-10-23 15:41:30Z

1

It's a problem, that useJob is expecting an interface instead of a function type directly. This way you can only do:

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

useJob(bar)

answered Oct 23, 2017 at 15:41

s1m0nw1

83k17 gold badges181 silver badges200 bronze badges

Comments

jrtapsell · Accepted Answer · 2017-10-23 18:03:42Z

0

You could do it like this:

// 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()
}

It requires a bit more code for the FooBar object, but it cleans up the call sites.

answered Oct 23, 2017 at 18:03

jrtapsell

7,0491 gold badge30 silver badges50 bronze badges

1 Comment

cuihtlauac Over a year ago

Nice code. Actually Param was a typo in Bar and T is a defined type, not a genericity parameter.

Collectives™ on Stack Overflow

Lambda in multiple type object expression

4 Answers 4

Comments

Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related