Scala for Backend Engineering & Functional Programming · Aula

Parâmetros implícitos

Passe contexto.

Parâmetros implícitos é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 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 Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Passando contexto automaticamente

Parâmetros implícitos permitem que o compilador forneça um argumento por você, obtido de valores marcados como implicit no escopo. Eles são ótimos para passar contexto "ambiente", como configurações ou regras de formatação.

object Main {
  def greet(name: String)(implicit greeting: String): String =
    s"$greeting, $name!"
  implicit val defaultGreeting: String = "Hello"
  def main(args: Array[String]): Unit = {
    println(greet("Ann"))
  }
}

A lista de parâmetros implícitos

Marque a última lista de parâmetros com a palavra-chave implicit. Quando você a omite no local da chamada, o compilador procura um valor implícito correspondente.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
  }
}

Fornecendo implícitos explicitamente

Você sempre pode passar um parâmetro implícito explicitamente, substituindo aquele disponível no escopo. Isso é útil em casos pontuais.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
    println(multiply(5)(2))
  }
}

Resolução de implícitos por tipo

O compilador associa os implícitos pelo tipo, não pelo nome. Deve haver exatamente um valor implícito correspondente no escopo; caso contrário, a compilação falha por ambiguidade ou ausência.

object Main {
  case class Config(env: String)
  def run()(implicit cfg: Config): String = s"running in ${cfg.env}"
  implicit val cfg: Config = Config("prod")
  def main(args: Array[String]): Unit = {
    println(run())
  }
}

implicitly para obter um valor

O auxiliar implicitly[T] obtém diretamente do escopo o valor implícito do tipo T, sem nomear um parâmetro.

object Main {
  implicit val name: String = "Scala"
  def main(args: Array[String]): Unit = {
    val n = implicitly[String]
    println(n)
  }
}

Abreviação de limite de contexto

Um limite de contexto [T: Ordering] é uma forma abreviada de um parâmetro implícito do tipo Ordering[T]. Ele é comum com classes de tipo.

object Main {
  def max[T: Ordering](a: T, b: T): T = {
    val ord = implicitly[Ordering[T]]
    if (ord.gt(a, b)) a else b
  }
  def main(args: Array[String]): Unit = {
    println(max(3, 7))
    println(max("apple", "pear"))
  }
}

Propagando contexto pelas chamadas

Os parâmetros implícitos são especialmente úteis quando várias funções precisam do mesmo contexto. Marque-o como implícito uma vez, e ele será propagado automaticamente pelas chamadas aninhadas.

object Main {
  case class User(name: String)
  def log(msg: String)(implicit u: User): Unit =
    println(s"[${u.name}] $msg")
  def doWork()(implicit u: User): Unit = {
    log("started")
    log("finished")
  }
  implicit val current: User = User("admin")
  def main(args: Array[String]): Unit = {
    doWork()
  }
}

Onde os implícitos são procurados

O compilador procura implícitos no escopo local, nas importações e nos objetos companheiros dos tipos envolvidos. Os objetos companheiros são um local organizado para fornecer valores padrão.

object Main {
  case class Currency(symbol: String)
  object Currency {
    implicit val default: Currency = Currency("$")
  }
  def price(amount: Int)(implicit c: Currency): String = s"${c.symbol}$amount"
  def main(args: Array[String]): Unit = {
    println(price(50))
  }
}

Erros de ambiguidade

Se houver dois implícitos do mesmo tipo no escopo, o compilador informará um erro de implícito ambíguo. Mantenha no máximo um por tipo ou passe o valor explicitamente.

object Main {
  def label(x: Int)(implicit unit: String): String = s"$x$unit"
  implicit val unit: String = "px"
  def main(args: Array[String]): Unit = {
    // Only one implicit String in scope -> no ambiguity
    println(label(12))
  }
}

Comportamento semelhante ao padrão

Os parâmetros implícitos fornecem uma forma de valores padrão sensíveis ao contexto: a mesma chamada de função produz resultados diferentes dependendo do implícito disponível no escopo.

object Main {
  def format(n: Double)(implicit decimals: Int): String =
    f"$n%.${decimals}f"
  implicit val d: Int = 2
  def main(args: Array[String]): Unit = {
    println(format(3.14159))
    println(format(3.14159)(4))
  }
}

Use implícitos com moderação

Os parâmetros implícitos são poderosos, mas podem dificultar a compreensão do código quando usados em excesso. Reserve-os para contextos realmente transversais, como contextos de execução, configurações e instâncias de classes de tipo.

object Main {
  case class Locale(code: String)
  def hello()(implicit loc: Locale): String =
    if (loc.code == "tr") "Merhaba" else "Hello"
  implicit val loc: Locale = Locale("tr")
  def main(args: Array[String]): Unit = {
    println(hello())
  }
}

Verificação rápida

Como o compilador decide qual valor fornecer para um parâmetro implícito?

Recapitulação

Você aprendeu sobre parâmetros implícitos (no estilo do Scala 2):

Marque uma lista de parâmetros como implicit para que ela seja preenchida automaticamente
A resolução é feita pelo tipo, que deve ser único no escopo
implicitly[T] obtém um valor; limites de contexto [T: TC] são uma abreviação
A busca abrange o escopo local, as importações e os objetos companheiros
Use-os para contexto transversal, não para tudo

Perguntas Frequentes

A aula “Parâmetros implícitos” é grátis?

Sim — o texto completo de “Parâmetros implícitos” é 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 Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Parâmetros implícitos”?

Passe contexto. Você pratica Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming 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 1 de 4.

Quanto tempo leva a aula “Parâmetros implícitos”?

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 Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming 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

← Voltar para Scala for Backend Engineering & Functional Programming