Kotlin Academy · Lezione

Creazione di API simili a DSL

Utilizzi infix per maggiore chiarezza

Creazione di API simili a DSL è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Infix per maggiore chiarezza

Le funzioni infix sono un elemento costitutivo delle DSL di Kotlin (linguaggi specifici del dominio). Rendono le chiamate API simili a frasi naturali.

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

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

Un'idea per un builder fluido

Combinare infix con tipi piccoli consente di esprimere l'intento in modo dichiarativo.

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

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

Configurazione basata su Pair

La funzione infix to consente di creare mappe di configurazione leggibili.

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

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

DSL per gli intervalli

Grazie a infix, i builder di intervalli si leggono come l'inglese.

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

Combinare le condizioni

È possibile creare frasi leggibili simili a espressioni booleane con le funzioni infix.

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)
}

Lambda con ricevitori

Le DSL autentiche spesso combinano infix con lambda dotate di ricevitori, consentendo a un blocco di configurare direttamente un oggetto.

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)
}

Spiegazione delle lambda con ricevitore

Un tipo funzione come Html.() -> Unit esegue il blocco come se si trovasse all'interno dell'istanza Html, quindi è possibile chiamare i membri senza un prefisso.

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 come mini DSL

La funzione standard apply è essa stessa una DSL basata su una lambda con ricevitore, per configurare un oggetto.

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

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

Mantenga leggibili le DSL

Una buona DSL riduce al minimo il rumore. Preferisca nomi che facciano leggere il punto di chiamata come una descrizione dell'intento.

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)
}

Infix più lambda

Combinare le funzioni infix con le lambda produce builder espressivi.

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)
}

Quando creare una DSL

Le DSL sono utili per configurazioni ripetitive e strutturate (interfacce utente, builder, test). Per la logica occasionale, le normali funzioni sono più semplici.

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

Verifica rapida

Verifichi la Sua comprensione delle API simili alle DSL.

Riepilogo

Ha imparato a creare API simili alle DSL:

Le funzioni infix fanno leggere le chiamate come frasi.
Le lambda con ricevitore (Type.() -> Unit) consentono ai blocchi di configurare direttamente gli oggetti.
apply e buildList sono DSL della libreria standard.
Utilizzi le DSL per configurazioni strutturate e ripetitive; le mantenga leggibili.

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

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

Domande Frequenti

La lezione «Creazione di API simili a DSL» è gratuita?

Sì — il testo completo di «Creazione di API simili a DSL» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Creazione di API simili a DSL»?

Utilizzi infix per maggiore chiarezza Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Creazione di API simili a DSL»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy