Faites un Cmd+clic (ou Ctrl+clic) sur n'importe quelle fonction qu'Inara a générée pour vous, et vous tombez sur du code que vous comprenez d'un coup d'œil. Ce n'est pas un heureux hasard : c'est la règle sur laquelle Inara est construite.
Inara génère toujours du code concis, que vous pouvez comprendre d'un coup d'œil. Il est toujours facile de comprendre comment et pourquoi il fonctionne, ce qui simplifie grandement le débogage.
Dans l'annonce d'Inara, j'ai écrit que je veux comprendre ce qui se passe dans mon code. Cet article ouvre le capot sur les cas généraux : un module, sa fonction de construction, ses bindings, une factory. Petit spoiler : il n'y a pas grand-chose à voir. C'est tout l'intérêt.
Mais la vraie preuve se trouve dans votre propre projet. Si vous utilisez Inara, je vous encourage vivement à lire le code qu'elle génère pour vos propres modules : un Cmd+clic suffit.

À qui appartient cette base de données ?
Avant de lire le moindre code généré, laissez-moi vous dire ce que j'en suis venu à détester dans les frameworks de DI classiques, comme Kodein DI.
Dans la plupart d'entre eux, chaque binding passe par son type. Les modules sont anonymes : ce sont des ensembles de bindings qui n'ont pas d'existence propre. Une fois chargés, ils se dissolvent dans un conteneur, et il ne reste qu'une grande table de correspondance à laquelle on demande « une base de données ».
Mais je ne veux pas une base de données. Je veux la base de données nommée database, dans ce module.
C'est toute la différence entre un type et une identité. Et donner une identité aux modules, c'est construire une architecture explicite : on voit quel module fournit quoi, et quel module dépend de quel autre.
Dans Inara, un module est une interface, il a donc évidemment un nom à la compilation. Ce qui est moins évident, et ce que montre la suite de cet article, c'est qu'il garde cette identité jusque dans le code généré, et jusqu'à l'exécution.
Ce que vous écrivez, ce qu'écrit KSP
Reprenons le module de l'annonce :
@DIModule
interface NetworkModule {
val baseUrl: String
fun httpClient(): HttpClient
}À partir de cette interface, le processeur d'Inara écrit un fichier nommé InaraNetworkModule.kt. En voici le cœur :
@InternalInaraGeneration
public class InaraNetworkModule(
public val baseUrlBinding: Binding<NetworkModule, Unit, String>,
public val httpClientBinding: Binding<NetworkModule, Unit, HttpClient>,
) : NetworkModule {
override val baseUrl: String
get() = this.baseUrlBinding.get(this, Unit)
override fun httpClient(): HttpClient = this.httpClientBinding.get(this, Unit)
}C'est tout : une classe qui implémente votre interface, avec un champ par membre.
Il n'y a aucune table indexée par type, et rien n'est recherché. Le httpClient() de NetworkModule est, littéralement, un champ nommé httpClientBinding. Quand vous appelez network.httpClient(), vous appelez une méthode qui lit un champ.
Remarquez aussi le this passé à get. C'est pour cela que le corps d'un binding voit le module comme récepteur, et peut lire baseUrl quand il construit le HttpClient. Pas de portée astucieuse ici : le module se passe simplement lui-même.
Le compilateur valide le graphe
À côté de la classe, Inara génère la fonction de construction que vous appelez pour créer un module :
public fun NetworkModule( baseUrl: Binding<NetworkModule, Unit, String>, httpClient: Binding<NetworkModule, Unit, HttpClient>, ): NetworkModule = InaraNetworkModule( baseUrlBinding = baseUrl, httpClientBinding = httpClient, )
Un paramètre par membre, sans valeur par défaut. Alors, que se passe-t-il si vous en oubliez un ?
val network = NetworkModule(
baseUrl = Binding.value("https://kodein-koders.com/wp-json/"),
)e: file:///…/Main.kt:5:15 No value passed for parameter 'httpClient'.
Voilà toute la « vérification des dépendances à la compilation ». Aucun algorithme de résolution de graphe derrière : c'est le compilateur Kotlin qui fait ce qu'il fait toujours avec un appel de fonction. Ajoutez un membre à l'interface, et chaque appel de construction qui ne lui fournit pas de binding cesse de compiler, avec un message d'erreur que tout développeur Kotlin comprend déjà.
Un binding est un tout petit objet
Mais alors, qu'est-ce qu'un binding, au juste ? Voici l'interface du runtime d'Inara, sans sa documentation ni ses fonctions de création :
public interface Binding<in M, in A, out T> {
public fun get(module: M, arg: A): T
public fun copyBinding(): Binding<M, A, T>
}get produit une valeur pour un module et un argument. Gardez copyBinding en tête : nous y reviendrons dans le prochain article.
Binding.value renvoie sa valeur. Binding.provider appelle sa lambda avec le module. Et voici comment Binding.single obtient sa valeur, avec la sûreté de thread par défaut :
@Volatile private var value: Any? = Uninitialized
private val lock = ReentrantLock()
override fun get(module: M, arg: Unit): T {
value.ifInitialized<T> { return it }
return lock.withLock {
value.ifInitialized<T> { return it }
builder(module).also { value = it }
}
}Un champ @Volatile et un verrou à double vérification. Vous avez sans doute déjà écrit exactement ce code vous-même.
Le runtime entier, toutes plateformes confondues, fait environ 420 lignes de code, sans compter les commentaires ni les lignes vides. Cela comprend tous les types de bindings, leurs variantes suspend, les annotations et les verrous propres à chaque plateforme. Vous pouvez tout lire pendant une pause café.
Les factories : une concession, rendue lisible
Je dois être honnête. Il y a un endroit où Inara résout bien les dépendances par type : @DIFactory.
class UsersApi(val httpClient: HttpClient) @DIFactory(builds = UsersApi::class, from = NetworkModule::class) object UsersApiFactory
Une factory construit une classe métier à partir d'un module, et affecte chaque argument du constructeur à partir d'un membre de ce module, trouvé par son type. C'est une concession, faite pour que les classes métier ignorent totalement Inara.
Mais cette concession s'accompagne de deux règles qui me tiennent profondément à cœur.
La première, et la plus importante : la fonction générée est facile à lire.
public fun UsersApiFactory.UsersApi(module: NetworkModule): UsersApi = UsersApi( httpClient = module.httpClient(), )
C'est le principe de l'introduction à l'œuvre : faites un Cmd+clic (ou Ctrl+clic) sur UsersApiFactory.UsersApi(network), et vous voyez exactement d'où vient la dépendance : de quel module, et de quel membre de ce module.
La seconde : la résolution se fait à la compilation. Si une dépendance est ambiguë, parce que deux membres de même priorité correspondent, le code ne compile pas. Si elle manque, elle devient un paramètre de la fonction générée, et le compilateur s'assure que chaque appelant la fournit. Dans les deux cas, il faut être explicite, par exemple avec une fonction arg dans l'objet factory :
@DIFactory(builds = Repository::class, from = StorageModule::class)
object RepositoryFactory {
internal fun StorageModule.argDatabase(): Database = sqlDatabase()
}En bref : soit c'est évident et inspectable, soit cela doit être explicité. Il n'y a pas de troisième option où un framework choisit quelque chose à votre place sans rien dire.
Le module connaît son propre nom
Vous vous souvenez de l'identité dont nous parlions ? Un module généré ne la perd pas à l'exécution. Affichez-en un :
val network = NetworkModule(
baseUrl = Binding.value("https://kodein-koders.com/wp-json/"),
httpClient = Binding.single { HttpClient(baseUrl) },
)
println(network)module NetworkModule {
val baseUrl: String => value ( String )
fun httpClient(): HttpClient => single(Synchronized) { HttpClient }
}Le module vous donne son nom, chacun de ses membres, et la façon dont chacun est lié. Quand un test ne se comporte pas comme prévu, il vous montre d'un coup d'œil quel binding porte réellement chaque membre.
Et puis, il y a copy et shadow
Inara génère aussi deux fonctions pour dériver un module d'un autre : copy et shadow. Ce sont, elles aussi, de simples fonctions d'extension, que vous pouvez lire dans le même fichier. Mais elles ne se comportent pas de la même façon, et cette différence en dit long sur la façon dont les bindings voient leur module. Ce sera l'histoire du prochain article.
Pas de tour de magie, seulement du code
Je ne veux pas d'une librairie de DI qui fait des choses astucieuses dans mon dos. J'en veux une dont je peux lire chaque ligne, et dont je peux suivre chaque dépendance d'un clic.
Voilà ce qu'est Inara : une interface que vous écrivez, une classe qu'elle écrit, et un compilateur qui vérifie le câblage. La prochaine fois que vous construisez un module, ouvrez build/generated/ksp et lisez Inara<YourModule>.kt. Cela devrait vous prendre une minute environ. Sinon, c'est un bug, et j'aimerais beaucoup en entendre parler.
Rejoignez la discussion :
Inara has no magic: Cmd+click on the code it generates, and you understand it at a glance. A module becomes a class with one field per member. Forget a binding, and the builder call doesn't compile. The whole runtime is about 420 lines. kodein-koders.com/en/blog/inar... #Kotlin #KMP #KSP
— kodein-koders.bsky.social (@kodein-koders.bsky.social) 6:01 PM · Nov 17, 2026
[image or embed]
Ces articles pourraient vous plaire
Tutoriels, retours d'expérience et bonnes pratiques autour de KOSI et de l'écosystème Kotlin, par ceux qui maintiennent les librairies.
09/11/2026
LARPing enthusiasm : le spectre du désengagement
Je peux confier le travail à l'IA, pas le jugement ni le sens du produit. Récit d'un glissement vers le désengagement, et d'une reconquête en cours.
Lire plus
02/11/2026
Inara : injectez vos dépendances à la compilation
J'ai créé Kodein, et pourtant je crois aujourd'hui qu'il nuit à l'écosystème Kotlin Multiplatform. Voici Inara, un Kotlin Symbol Processor qui résout vos dépendances à la compilation, et découvrez pourquoi nous mettons Kodein en fin de vie.
Lire plus
26/10/2026
Les agents de code ont tué les frameworks multiplateformes !
Avec les agents, écrire deux fois du code natif ne coûte presque plus rien : le multiplateforme est-il mort ? Pas vraiment : c'est la question qui a changé. Partagez ce qui doit être identique, et vérifiez-le une seule fois.
Lire plus
19/10/2026
LARPing enthusiasm : la frénésie créative de l’IA
L'IA me permet de construire en quelques semaines ce qui demandait des années, et c'est grisant comme une drogue. Est-ce que je crée vraiment, ou est-ce que je joue l'enthousiasme ? Une réflexion personnelle sur la volonté, l'agentivité et le code partagé.
Lire plus
17/10/2026
MocKMP : un processeur de mocking pour Kotlin/Multiplatform
Envie d'exécuter vos tests unitaires sur toutes les cibles Kotlin/Multiplatform ? MocKMP génère mocks et fakes à la compilation avec un Kotlin Symbol Processor, sans réflexivité, et conserve une API de mocking familière.
Lire plus
04/09/2025
Utiliser Swift dans une librairie Kotlin/Multiplatform
Besoin d'utiliser une API iOS réservée à Swift, comme CryptoKit, dans votre librairie Kotlin/Multiplatform ? Salomon montre comment la relier via Objective-C et le cinterop de Kotlin/Native, avec du code testé.
Lire plus