I have a use case that is causing some trouble. We...

# announcements

[Eric Martori]

I have a use case that is causing some trouble. We have an interface:

interface Foo<T> { 
   fun bar(t: T)
 }

And we want to be able to have the same interface but without the parameter:

interface Foo {
    fun bar()
}

but this is not possible because we are redeclaring the interface name. A possible solution is to declare Foo<Unit> and pass Unit instead of having the second interface without parameters, but this verbose on the calling and declaration site.
We have an extension function fun Foo<Unit>.bar() = bar(Unit) to make the calling site clearer, but declaring it is still a little bit cumbersome.

Any ideas on how to achieve this?

[Melih Aksoy]

Extracting parameter from interface would work.

interface Foo {
    fun <T> bar(t: T)
    fun bar()
}

[wbertan]

I see as the Function0, Function1, etc.

interface Foo0 : () -> Unit
    interface Foo1<in T> : (T) -> Unit

    class A : Foo1<Int> {
        override fun invoke(p1: Int) = TODO()
    }

    class B : Foo0 {
        override fun invoke() = TODO()
    }

[karelpeeters]

@Melih Aksoy That's something completely different, now implementors of that interface need to be able to handle anything instead of only a single type.

[diesieben07]

How about a typealias?
typealias FooU = Foo<Unit>

[diesieben07]

That plus your extension function should make this quite seamless

[Eric Martori]

@wbertan potentially the interface can have other methods so implementing function might not be a solution. Also, we end up declaring different interface names for each number of parameters.

[Eric Martori]

@diesieben07 This is what we are using right now, but still doesn't feel 100% having to write that U at the end. But is the best we have managed so far

[wbertan]

@Eric Martori This is kind of what Kotlin does: https://github.com/JetBrains/kotlin/blob/master/libraries/stdlib/jvm/runtime/kotlin/jvm/functions/Functions.kt

Give this example based on your example where isn't showing other methods.
Anyway you could implement two interfaces:

interface OtherFoo {
        fun doSomethingElse()
    }
    interface Foo0: OtherFoo {
        fun doSomething()
    }
    interface Foo1<in T>: OtherFoo {
        fun doSomething(param: T)
    }

    class A : Foo1<Int> {
        override fun doSomething(param: Int) = TODO()
        override fun doSomethingElse() = TODO()
    }

    class B : Foo0 {
        override fun doSomething() = TODO()
        override fun doSomethingElse() = TODO()
    }