Using java code i can use interface with a single ...

# announcements

[Daniele Segato]

Using java code i can use interface with a single method just by using the interface name, like this:

val x = SomeInterface { }

Thanks to SAM.

However when i try the same thing on kotlin interface I'm forced to create an anonymous class:

val x = object : SomeInterface {
  fun someMethod() { }
}

If i instead create a type alias for it I can write it without the object ceremony but I've no way of specifying what it is:

typealias SomeInterface = (): Unit

// ...

val x = { }

Yes i know i can do

val x: SomeInterface = { }

But picture this situation:

val x: SomeInterface = when (foo) {
  "A" -> { { } }
  "B" -> { { } }
}

I need double {, which is horrible.

I think it would be much better to be able to write;

val x = when (foo) {
  "A" -> SomeInterface { }
  "B" -> SomeInterface { }
}

Is there a way to do this or a way to improve the previous example?

[Daniele Segato]

Please can you reply in thread?

[Daniele Segato]

This might be related: https://youtrack.jetbrains.com/issue/KT-7770

[bezrukov]

I think you can declare top level function fun SomeInterface(lambda): SomeInterface = lambda
Then you will be able to do what you want

[Daniele Segato]

Thanks for the tip, i can make it inline to remove any friction and just improve the code readability. Thanks!

[Daniele Segato]

it was easy afterall, didn't though of top level functions

typealias SomeInterface = (param: SomeParam) -> SomeResult

@Suppress("NOTHING_TO_INLINE", "FunctionName")
inline fun SomeInterface(noinline lambda: SomeInterface): SomeInterface = mapper

and now I can write a more readable code :)

[Hullaballoonatic]

alternatively you can add an invoke operator to the interfaces' companion object. I prefer this approach, but obviously you can't do that to a java class, though

[Daniele Segato]

@Hullaballoonatic I'm sorry I fail to understand what you mean

do you mean something like:

interface SomeInterface {
  operator fun invoke(param: SomeParam): SomeResult
}

?

or do you mean like this?

interface SomeInterface {
  fun doStuff(param: SomeParam): SomeResult
  companion object {
    operator fun invoke(lambda: SomeInterface): SomeInterface = lambda
  }
}

?

If you meant any of those, I fail to see how they'd help in my situation / how to make use of them.

Can you give an example of what you meant and how to use it?
Thanks