Tukukkk

I'm trying to find a Kotlin-based dependency injection system that will allow me to bind generic types like Foo<T> and resolve Foo<Int>, Foo<String>, etc. as needed.

Kodein seems to be one of the more popular DI frameworks and I've looked into that, but don't see how it's possible. Issue #83 in the Kodein repository has some discussion around this topic.

In my case, I'd like to be able to do something like this:

import com.atpgroup.testmaster.domain.ExecutableNode

import kotlin.reflect.KClass



annotation class TypeClass

annotation class Instance



/**

 * Represents a catalog of nodes.

 *

 * Factory functions to generate nodes are initially registered to this catalog during setup and used to create

 * instances of nodes.

 */

interface NodeCatalog {

    fun <U : ExecutableNode> resolve(nodeType: KClass<U>, id: String): U

}



/**

 * Simplifies resolution of nodes from a reified context.

 */

inline fun <reified T : ExecutableNode> NodeCatalog.resolve(id: String) = resolve(T::class, id)



/**

 * Dummy implementation of a node catalog.

 */

class DummyNodeCatalog : NodeCatalog {

    override fun <U : ExecutableNode> resolve(nodeType: KClass<U>, id: String): U = TODO("not implemented")

}



/**

 * A type class representing the set of types that can behave like numbers.

 */

@TypeClass

interface Num<T>



// Int and Double both behave like numbers.

@Instance object IntNumInstance : Num<Int>

@Instance object DoubleNumInstance : Num<Double>



/**

 * An executable node that adds two numbers together.

 *

 * @param T the type of the numbers that will be added together

 */

class AddNode<T>(override val id: String, private val N: Num<T>) : ExecutableNode {

    override suspend fun execute() = TODO("not implemented")

}



// Resolve two "add nodes" that operate on different types of numbers.

val catalog = DummyNodeCatalog()

val addInts = catalog.resolve<AddNode<Int>>("integer adder")

val addDoubles = catalog.resolve<AddNode<Double>>("double adder")

In C# this is pretty straightforward using Autofac. The snippet below is a working implementation in C# of what I'd like:

using System;

using Autofac;



namespace Experiment

{

    internal class Program

    {

        public static void Main()

        {

            var builder = new ContainerBuilder();



            builder.RegisterType<IntNumInstance>().As<INum<int>>();

            builder.RegisterType<DoubleNumInstance>().As<INum<double>>();

            builder.RegisterGeneric(typeof(Add<>));



            var container = builder.Build();

            var addA = container.Resolve<Add<int>.Factory>()("add integers");

            var addB = container.Resolve<Add<double>.Factory>()("add doubles");

            Console.WriteLine(addA);

            Console.WriteLine(addB);

            Console.ReadLine();

        }

    }



    interface INum<T> {}

    class IntNumInstance : INum<int> {}

    class DoubleNumInstance : INum<double> {}



    class Add<T>

    {

        public delegate Add<T> Factory(string id);



        public Add(string id, INum<T> N)

        {

            Id = id;

            this.N = N;

        }



        public string Id { get; }



        private INum<T> N { get; }



        public override string ToString() => $"Add Node ({Id} - {N})";

    }

}

Output

Add Node (add integers - Experiment.IntNumInstance)

Add Node (add doubles - Experiment.DoubleNumInstance)