使用委托在 Kotlin 中实现 Mixins（或 Traits）

class myclass {
    private val mixin = counter()

    fun myfunction() {
        mixin.increment()

        // ...
    }
}

interface counter {
    var count: int
    fun increment() {
        println("mixin does its job")
    }
    fun get(): int = count
}

class myclass: counter {
    override var count: int = 0 // we are forced to add the mixin's state to the class using it

    fun hello() {
        println("class does something")
    }
}

interface counter {
    fun increment()
    fun get(): int
}

class counterholder: counter {
    var count: int = 0
    override fun increment() {
        count++
    }
    override fun get(): int = count
}

class myclass: counter by counterholder() {
    fun hello() {
        increment()
        // the rest of the method...
    }
}

interface counter {
    // the functions and properties defined here constitute the mixin's "interface contract." this can be used by the class using the mixin or from outside of it.
    fun increment()
    fun get(): int

    companion object {
        private class mixinstateholder : counter {
            // the mixin's state can be defined here, and it is private if not also defined in the interface
            var count: int = 0

            override fun increment() {
                count++
            }
            override fun get(): int = count
        }

        // using the invoke operator in a companion object makes it appear as if the interface had a constructor. normally i discourage this kind of black magic, but here it seems one of the rare justified cases. if you don't like it, rename this function using a standard name common to all mixins like `init` or `create`.
        operator fun invoke(): counter {
            return mixinstateholder()
        } 
    }
}

class myclass: counter by counter() {
    fun myfunction() {
        this.increment()
        // the rest of the method...
    }
}

    class myclass: mymixin by mymixin(this) {} // compilation error: `this` is not defined in this context

import java.time.instant

data class timestampedevent(
    val timestamp: instant,
    val event: string
)

interface auditable {
    fun auditevent(event: string)
    fun getlatestevents(n: int): list<timestampedevent>

    companion object {
        private class holder : auditable {
            private val events = mutablelistof<timestampedevent>()
            override fun auditevent(event: string) {
                events.add(timestampedevent(instant.now(), event))
            }
            override fun getlatestevents(n: int): list<timestampedevent> {
                return events.sortedbydescending(timestampedevent::timestamp).takelast(n)
            }
        }

        operator fun invoke(): auditable = holder()
    }
}

class bankaccount: auditable by auditable() {
    private var balance = 0
    fun deposit(amount: int) {
        auditevent("deposit $amount")
        balance += amount
    }

    fun withdraw(amount: int) {
        auditevent("withdraw $amount")
        balance -= amount 
    }

    fun getbalance() = balance
}

fun main() {
    val myaccount = bankaccount()

    // this function will call deposit and withdraw many times but we don't know exactly when and how
    givetocomplexsystem(myaccount)

    // we can query the balance of the account
    myaccount.getbalance()

    // thanks to the mixin, we can also know the operations that have been performed on the account.
    myaccount.getlatestevents(10)
}

interface observable<t> {
    fun subscribe(observer: (t) -> unit)
    fun notifyobservers(event: t)

    companion object {
        private class holder<t> : observable<t> {
            private val observers = mutablelistof<(t) -> unit>()
            override fun subscribe(observer: (t) -> unit) {
                observers.add(observer)
            }

            override fun notifyobservers(event: t) {
                observers.foreach { it(event) }
            }
        }

        operator fun <t> invoke(): observable<t> = holder()
    }
}

sealed interface catalogevent
class priceupdated(val product: string, val price: int): catalogevent

class catalog(): observable<catalogevent> by observable() {
    val products = mutablemapof<string, int>()

    fun updateprice(product: string, price: int) {
        products[product] = price
        notifyobservers(priceupdated(product, price))
    }
}

fun main() {
    val catalog = catalog()

    catalog.subscribe { println(it) }

    catalog.updateprice("lamp", 10)
}

interface Entity {
    val id: UUID

    // Overriding equals and hashCode in a mixin may not always be a good idea, but it seems interesting for the example.
    override fun equals(other: Any?): Boolean
    override fun hashCode(): Int
}

class IdentityHolder(
    override val id: UUID
): Entity {
    // Two entities are equal if their ids are equal.
    override fun equals(other: Any?): Boolean {
        if(other is Entity) {
            return this.id == other.id
        }

        return false
    }

    override fun hashCode(): Int {
        return id.hashCode()
    }
}

class Customer(
    id: UUID,
    val firstName: String,
    val lastName: String,
) : Entity by IdentityHolder(id)

val id = UUID.randomUUID()
val c1 = Customer(id, "John", "Smith")
val c2 = Customer(id, "John", "Doe")

c1 == c2 // true