I'm trying to do something with Kotlin just for th...

# announcements

[Manuel Pérez Alcolea]

I'm trying to do something with Kotlin just for the sake of learning (and not for practical reasons). What I thought was: I want to see if I can have some sort of class built with mixins in Kotlin. That's not possible per-se since there's no multiple inheritance or any specific tool that allows it, but I tried to have a similar effect with delegates, knowing that by exists.

So, my idea was to have, for example, something like this...

[Manuel Pérez Alcolea]

Untitled

Untitled

[streetsofboston]

Yup, that would work. In your example, you can make Humanoid and interface as well.

[Manuel Pérez Alcolea]

the issue comes when I want to give it the behaviour of actual mixins - that is, I want to simulate it by allowing each interface/implementation of them have access to the Person class

[Manuel Pérez Alcolea]

for example

[Manuel Pérez Alcolea]

If I want the interfaces to have access to Person.name, I need to give them a reference to that instance of Person. The issue is, I can only do so by sacrificing some null safety, because, for example, in the constructor for Person, talker and walker need a reference to the Person - which is not possible because it's still being created (it's the constructor, after all, and there's no this for Person yet)

Untitled.kt

[Manuel Pérez Alcolea]

so I'm not saying it's not possible to have "the effect I want"

[Manuel Pérez Alcolea]

but I only found two solutions, and I'm wondering if Kotlin can help me. I'm basically pushing the language to see what it can do for me

[Manuel Pérez Alcolea]

this is one of them:

[Manuel Pérez Alcolea]

Which looks a bit silly to me.

Untitled

[Manuel Pérez Alcolea]

basically, make Person just wrap the data, and give the implementations for the interfaces some constructors so it can be passed to them as well

[Manuel Pérez Alcolea]

so no issue there: everything is still immutable and safe, etc. and "just werks"

[streetsofboston]

Kotlin does not have true mixins like that…..

[Manuel Pérez Alcolea]

the other solution is making it look like Java: either by not using by and setting all the methods myself and/or make the interfaces have nullable properties, so I can pass them the reference after building the Person

[Manuel Pérez Alcolea]

ah, okay, I get it

[Manuel Pérez Alcolea]

I was just having fun and that was technically all I wanted to know, thanks

[streetsofboston]

Or something like this?.. More kotliny… 🙂

interface Trait<M> {
    var m: () -> M
}

interface CanMove {
    fun move()
}

interface CanCommunicate {
    fun communicate()
}

interface TraitCanMove : CanMove, Trait<Person> {
    override fun move() {
        println("Moving person ${m().name}")
    }
}

interface TraitCanCommunicate : CanCommunicate, Trait<Person> {
    override fun communicate() {
        println("Talking to person ${m().name}")
    }
}

class Person private constructor(
    walker: TraitCanMove,
    talker: TraitCanCommunicate,
    val name: String
) : CanMove by walker, CanCommunicate by talker {
    companion object {
        operator fun invoke(
            walker: TraitCanMove,
            talker: TraitCanCommunicate,
            name: String
        ): Person {
            return { Person(walker, talker, name) }.prepareTraits(walker, talker)
        }
    }
}

fun <T> (() -> T).prepareTraits(vararg traits: Trait<T>): T {
    traits.forEach { it.m = this }
    return this()
}

[Manuel Pérez Alcolea]

Oh... I see the idea, but there's probably something about Kotlin I'm not aware of. The companion object works as a factory there, but TraitCanMove and TraitCanCommunicate are interfaces, which is what it asks for. So should I implement classes with them as base too, @streetsofboston?

[streetsofboston]

Yes, you can do that.

Using the companion object and the operator function invoke, you can define so-called smart-constructors.

[streetsofboston]

Also, the code snippet I posted is just an idea.... not tested or vetted at all 😀

[Manuel Pérez Alcolea]

ah, I see

[streetsofboston]

You may want to replace the `() -> T`s with `Lazy<T>`s....

[Manuel Pérez Alcolea]

anyway, it showed me some things I didn't think about, so it's still great for me, Kotlin is still alien to me in some basic areas, even though I think I can read most of it without issues

[Manuel Pérez Alcolea]

so I'm grateful to learn

[Manuel Pérez Alcolea]

many thanks