Kotlin Academy · Leçon

Créer des API de type DSL

Utiliser l’infixation pour plus de clarté

Créer des API de type DSL est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

L'infixe pour plus de clarté

Les fonctions infixes sont un élément constitutif des DSL Kotlin (langages spécifiques à un domaine). Elles permettent de lire les appels d'API comme des expressions naturelles.

infix fun String.eq(value: String) = this == value

fun main() {
    println("on" eq "on")
}

Une idée de générateur fluide

Associer l'infixe à de petits types permet d'exprimer l'intention de manière déclarative.

class Query(val field: String) {
    infix fun equals(value: String) = "$field = '$value'"
}

fun main() {
    val q = Query("name") equals "Sam"
    println(q)
}

Configuration fondée sur des paires

La fonction infixe to permet de construire des cartes de configuration lisibles.

fun configure(vararg opts: Pair<String, Any>) = opts.toMap()

fun main() {
    val cfg = configure("debug" to true, "level" to 3)
    println(cfg)
}

DSL de plages

Grâce à l'infixe, les générateurs de plages se lisent comme des phrases en français.

fun main() {
    val r = 1 until 10 step 2
    println(r.toList())
}

Combiner des conditions

Vous pouvez créer des expressions lisibles, semblables à des phrases booléennes, avec des fonctions infixes.

data class Rule(val ok: Boolean) {
    infix fun and(other: Rule) = Rule(ok && other.ok)
}

fun main() {
    val result = Rule(true) and Rule(false)
    println(result.ok)
}

Lambdas avec récepteurs

Les véritables DSL associent souvent l'infixe à des lambdas dotées de récepteurs, ce qui permet à un bloc de configurer directement un objet.

class Html {
    val parts = mutableListOf<String>()
    fun p(text: String) { parts.add("<p>$text</p>") }
}

fun html(block: Html.() -> Unit): Html {
    val h = Html()
    h.block()
    return h
}

fun main() {
    val page = html { p("Hi") }
    println(page.parts)
}

Explication des lambdas avec récepteur

Un type de fonction tel que Html.() -> Unit fait s'exécuter le bloc comme s'il se trouvait à l'intérieur de l'instance Html ; ses membres peuvent donc être appelés sans préfixe.

class Box { var value = 0 }

fun box(init: Box.() -> Unit): Box {
    val b = Box()
    b.init()
    return b
}

fun main() {
    val b = box { value = 42 }
    println(b.value)
}

apply comme mini-DSL

La fonction standard apply est elle-même un DSL fondé sur une lambda avec récepteur, destiné à configurer un objet.

class Server {
    var host = ""
    var port = 0
}

fun main() {
    val s = Server().apply {
        host = "localhost"
        port = 8080
    }
    println("${s.host}:${s.port}")
}

Garder les DSL lisibles

Un bon DSL réduit le bruit au minimum. Privilégiez des noms qui font lire l'appel comme une description de l'intention.

data class Style(var bold: Boolean = false)

fun style(block: Style.() -> Unit) = Style().apply(block)

fun main() {
    val s = style { bold = true }
    println(s.bold)
}

Infixe et lambda

Associer des fonctions infixes à des lambdas permet de créer des générateurs expressifs.

class Table {
    val rows = mutableListOf<String>()
    infix fun row(text: String) { rows.add(text) }
}

fun table(block: Table.() -> Unit) = Table().apply(block)

fun main() {
    val t = table {
        row("A")
        row("B")
    }
    println(t.rows)
}

Quand créer un DSL

Les DSL sont utiles pour les configurations répétitives et structurées (interfaces utilisateur, générateurs, tests). Pour une logique ponctuelle, les fonctions ordinaires sont plus simples.

fun main() {
    val list = buildList {
        add(1)
        add(2)
    }
    println(list)
}

Vérification rapide

Vérifiez votre compréhension des API inspirées des DSL.

Récapitulatif

Vous avez appris à créer des API inspirées des DSL :

Les fonctions infixes permettent de lire les appels comme des phrases.
Les lambdas avec récepteur (Type.() -> Unit) permettent aux blocs de configurer directement des objets.
apply et buildList sont des DSL de la bibliothèque standard.
Utilisez les DSL pour les configurations structurées et répétitives, tout en les gardant lisibles.

class C { var x = 0 }
fun c(b: C.() -> Unit) = C().apply(b)

fun main() {
    println(c { x = 9 }.x)
}

Questions Fréquemment Posées

La leçon « Créer des API de type DSL » est-elle gratuite ?

Oui — le texte complet de « Créer des API de type DSL » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer des API de type DSL » ?

Utiliser l’infixation pour plus de clarté Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Créer des API de type DSL » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Kotlin Academy