Construção de APIs Semelhantes a DSL
Use infix para obter clareza
Construção de APIs Semelhantes a DSL é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.
Infixas para maior clareza
As funções infixas são um bloco de construção das DSLs do Kotlin (linguagens específicas de domínio). Elas fazem as chamadas da API parecerem frases naturais.
infix fun String.eq(value: String) = this == value
fun main() {
println("on" eq "on")
}Uma ideia de construtor fluente
Combinar funções infixas com tipos pequenos permite expressar a intenção de forma declarativa.
class Query(val field: String) {
infix fun equals(value: String) = "$field = '$value'"
}
fun main() {
val q = Query("name") equals "Sam"
println(q)
}Configuração baseada em pares
A função infixa to permite criar mapas de configuração legíveis.
fun configure(vararg opts: Pair<String, Any>) = opts.toMap()
fun main() {
val cfg = configure("debug" to true, "level" to 3)
println(cfg)
}DSL de intervalos
Os construtores de intervalos parecem frases em português graças às funções infixas.
fun main() {
val r = 1 until 10 step 2
println(r.toList())
}Combinando condições
Você pode criar frases legíveis semelhantes a expressões booleanas com funções infixas.
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 com receptores
As DSLs verdadeiras geralmente combinam funções infixas com lambdas que têm receptores, permitindo que um bloco configure um objeto diretamente.
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)
}Lambdas com receptores explicadas
Um tipo de função como Html.() -> Unit faz o bloco ser executado como se estivesse dentro da instância Html, portanto os membros podem ser chamados sem um prefixo.
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 como uma mini DSL
A função padrão apply é, por si só, uma DSL baseada em lambda com receptor para configurar um objeto.
class Server {
var host = ""
var port = 0
}
fun main() {
val s = Server().apply {
host = "localhost"
port = 8080
}
println("${s.host}:${s.port}")
}Mantenha as DSLs legíveis
Uma boa DSL minimiza o ruído. Prefira nomes que façam o local da chamada parecer uma descrição da intenção.
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)
}Infixa mais lambda
Combinar funções infixas com lambdas produz construtores expressivos.
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 criar uma DSL
As DSLs são úteis para configurações repetitivas e estruturadas (interfaces de usuário, construtores e testes). Para uma lógica pontual, as funções comuns são mais simples.
fun main() {
val list = buildList {
add(1)
add(2)
}
println(list)
}Verificação rápida
Teste sua compreensão sobre APIs semelhantes a DSLs.
Recapitulação
Você aprendeu a criar APIs semelhantes a DSLs:
- As funções infixas fazem as chamadas parecerem frases.
- As lambdas com receptores (
Type.() -> Unit) permitem que os blocos configurem objetos diretamente. applyebuildListsão DSLs da biblioteca padrão.- Use DSLs para configurações estruturadas e repetitivas, mantendo-as legíveis.
class C { var x = 0 }
fun c(b: C.() -> Unit) = C().apply(b)
fun main() {
println(c { x = 9 }.x)
}Perguntas Frequentes
A aula “Construção de APIs Semelhantes a DSL” é grátis?
Sim — o texto completo de “Construção de APIs Semelhantes a DSL” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.
O que vou aprender em “Construção de APIs Semelhantes a DSL”?
Use infix para obter clareza Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Kotlin Academy?
Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Construção de APIs Semelhantes a DSL”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Kotlin Academy?
Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Funções Infixas
- Construção de APIs Semelhantes a DSL
- Funções tailrec
- Quando Usar Cada Uma