klukwist

fun interface SamFoo {
    fun bar() : String
}

val samFoo = SamFoo {
    "hello world"
}

samFoo.bar()

klukwist

interface RegularFoo {
    fun bar() : String
}

val regularFoo = object  : RegularFoo {
    override fun bar(): String {
        return "hello world"
    }
}

klukwist

fun module(scope: SimpleDiScope.() -> Unit) {
    scope.invoke(SimpleDiScope)
}

klukwist

object SimpleDiScope {
    inline fun <reified T : Any> factory(factory: InstanceType.Factory<T>) {
        SimpleDiStorage.addFactory(factory)
    }

    inline fun <reified T : Any> factoryWithParams(factory: InstanceType.ParamFactory<T>) {
        SimpleDiStorage.addFactory(factory)
    }

    inline fun <reified T : Any> singleton(factory: InstanceType.Factory<T>) {

klukwist

inline fun <reified T : Any> get(noinline params: (Params.() -> Unit)? = null): T {
    return SimpleDiStorage.getInstance(params)
}

klukwist

@PublishedApi
internal object SimpleDiStorage {
    val instances = mutableMapOf<KClass<*>, InstanceType<*>>()

    inline fun <reified T : Any> addFactory(factory: InstanceType<T>) {
        check(instances[T::class] == null) {
            "Definition for ${T::class} already added."
        }
        instances[T::class] = factory
    }

klukwist

val aInstance = get<A>() // or val aInstance: A = get()

val bInstance = get<B>()

val cInstance = get<C> { 
    params(bInstance) 
}

klukwist

interface A {
    fun foo()
}

class AImpl: A {
    override fun foo() {
        print("A")
    }
}

klukwist

module {
    singleton<A> { AImpl() }
    factory<B> {
        BImpl(
            a = get()
        )
    }
    factoryWithParams<C> { (aParam) ->
        C(
            a = aParam as A,

klukwist

sealed interface InstanceType<T> {
    fun interface Factory<T> : InstanceType<T> {
        fun build(): T
    }

    fun interface ParamFactory<T> : InstanceType<T> {
        fun build(vararg params: Any): T

        class Params {
            var parameters: Array<out Any> = arrayOf()