Hi there, I've a question: I've this Class below ```@Factory class Foo: Mapper<X, Y> { o...

# koin

[Sagar Khurana]

Hi there, I've a question:

I've this Class below

@Factory
class Foo: Mapper<X, Y> {
    override fun convert(data: X): Y {
        return ...
        )
    }
}

and, Mapper interface

interface Mapper<in In, out Out> {
    fun convert(data: In): Out
}

I'm using the Koin annotations. When I use the annotation with just, let's say, @Factory, Koin automatically maps the dependency to provide the Mapper::class. However, I want to specifically map the dependency to the Mapper<X, Y> type. Using the @Named annotation achieves my goal, but I'm wondering if there's a better way to do it

[Alexandru Caraus]

Doesn't @Factory(binds = Mapper<X,Y>::class) work?

[Sagar Khurana]

No, it shows a compilation error of Only classes are allowed on the left hand side of a class literal

[Alexandru Caraus]

And if you change the interface to an abstract class?

[Alexandru Caraus]

https://github.com/Adnan9011/movie_archive/blob/master/domain/src/main/java/com/moviearchive/domain/di/DomainModule.kt

[Sagar Khurana]

The error remains the same Only classes are allowed on the left hand side of a class literal 😢 , in the above example you shared use case is a interface too

[Sagar Khurana]

Screenshot 2024-10-07 at 7.02.02 PM.png

[Alexandru Caraus]

The binding is done through dsl though

[Sagar Khurana]

So, this use case cannot be achieved via annotations?

[Alexandru Caraus]

Ah true, that will work as if you inject just Foo

[Alexandru Caraus]

Following works, and you don't need, @named

[Alexandru Caraus]

I think there is a request for this functionality though

[Alexandru Caraus]

Apparently its not possible with annotations

[Sagar Khurana]

Following works, and you don't need, @named

Sure, Koin works well when there is only one Foo, but when there are multiple implementation classes, Koin doesn't know which one to inject without the @named annotation.

[Sagar Khurana]

Then, from the discussion, there are two possible ways to achieve this:
1. DSL
2. Using @named annotation for annotations approach

[Alexandru Caraus]

True, @named is always need when you have two or more of the same type, normally you will have one mapper, Mapper<BoundaryModel1, BoundaryModel2>

[Alexandru Caraus]

if you have that, then in any case you need named

[Alexandru Caraus]

3. Is through Factory annotated function like above, you can also provide dependencies as parameters to the function, and annotate it with name if you have more of that type.

[Alexandru Caraus]

Hilt also does like that, through @Binds annotation, has the same constraint

[Sagar Khurana]

Thanks to @Alexandru Caraus for answering my questions. I'm implementing DI in our production Android project and using Koin annotations, but the changes are currently scattered. Thanks again for the help.

I have one more question, which I think is a bit dumb. I'll create a separate thread for it.

[Alexandru Caraus]

Np, I also just learned about it 🙂, so thank you too

[arnaud.giuliani]

Then, from the discussion, there are two possible ways to achieve this:

1. DSL

2. Using @named annotation for annotations approach

Effectively types are erased at runtime 👍