Is it possible to create an infix function scoped ...

# announcements

[eygraber]

Is it possible to create an infix function scoped to a specific class? Something like:

// Foo is a library class and out of my control
class Foo

infix fun Foo.togetherWith(first: Any, second: Any) = ...

inline fun fooBuilder(builder: Foo.() -> Unit) {
  Foo().apply(builder)
}

fooBuilder {
  1 togetherWith 2
}

I know this specifically doesn't work, but is there any way to achieve this behavior?

[Nir]

I think to do this you'd need to inherit from Foo

[Nir]

Or if that's not possible

[Nir]

Create a class that delegates, automatically or manually

[Nir]

And add the infix function too

[Animesh Sahu]

This was discussed in Kotlin 1.4 Event, as a proposal iirc.

[Nir]

What exactly?

[Animesh Sahu]

They were trying to fix a syntax, taking the suggestions from people. But don't know if it'll be implemented any before 1.5

[Nir]

IMHO the most natural path to fix this is to make delegation less clumsy

[Animesh Sahu]

There's a highly requested KEEP proposal, lemme check its link

[Nir]

Not obvious to me why delegation required an interface really

[Nir]

Requires

[Nir]

Delegation has some odd restrictions, there's probably reasons but it is pretty limiting in the end regardless

[Animesh Sahu]

Not all class members be overriden, they're final by default unless you open them

[Animesh Sahu]

Maybe ^

[Animesh Sahu]

https://www.youtube.com/watch?v=0FF19HJDqMo?t=13m20s▾

I think this talk discussed about this

[Animesh Sahu]

Yeah it is ^

[bezrukov]

You already can do this.
Declare your togetherWith function in Foo, rather than creating an extension function

[Animesh Sahu]

He explicitly said:

// Foo is a library class and out of my control

[bezrukov]

Ah see

[Nir]

@Animesh Sahu it's not overriding though it's just delegation

[bezrukov]

Then create FooBuilder class that proxies your lamda changes to actual Foo

[Nir]

It's code you can always write by hand, for any class, whether it's open or closed

[Nir]

Not sure if your video link is related to what I said about delegation or the original issue but I'll check it out

[Animesh Sahu]

I mean implementing a List through either LinkedList or ArrayList makes sense, but implementing a LinkedList with ArrayList looks meh... 😛

[Animesh Sahu]

What's the usecase?

[Nir]

You can't do that though... You can only delegate to a subtype

[Animesh Sahu]

I mean yeah, sorry for bad examples 😅

[Nir]

The use case is anytime you want to extend a class you don't control

[Nir]

Even more useful is if the delegation still allows you to implement any functions by hand and override the "default" implementation you get from the delegste

[Nir]

This "proxy" or "facade" is one of the original design patterns, already has language support in Kotlin, you better believe use cases are common :-)

[Animesh Sahu]

It gives you ability to iirc

[Nir]

Go also offers a language feature to deal with this use case

[Animesh Sahu]

override fun f(...) { super<Interface1>.f(...); super<If2>.f(...) }

[Nir]

Right, nice

[Animesh Sahu]

I have no idea of golang tbh sorry 😅

[Nir]

So yeah, just leaves the interface limitation, as well as some limitations of var val

[Nir]

Go has embedding. It's basically implementation inheritance, except that it doesn't make the class a subtype