Quais são todos os usos de um sublinhado no Scala?

Eu tomei um olhar para a lista de pesquisas taken on scala-lang.org e notei uma pergunta curiosa: " ‘Você pode nomear todos os usos de’_ ". Você pode? Se sim, faça-o aqui. Exemplos explicativos são apreciados.

Os que eu consigo pensar são

Tipos existenciais

def foo(l: List[Option[_]]) = ...

Parâmetros do tipo de classificação superior

case class A[K[_],T](a: K[T])

Variáveis ​​ignoradas

val _ = 5

Parâmetros ignorados

List(1, 2, 3) foreach { _ => println("Hi") }

Nomes ignorados de tipos próprios

trait MySeq { _: Seq[_] => }

Padrões curinga

Some(5) match { case Some(_) => println("Yes") }

Padrões curinga em interpolações

"abc" match { case s"a$_c" => }

Curinga da sequência nos padrões

C(1, 2, 3) match { case C(vs @ _*) => vs.foreach(f(_)) }

Importações curinga

import java.util._

Ocultando importações

import java.util.{ArrayList => _, _}

Associando cartas aos operadores

def bang_!(x: Int) = 5

Operadores de atribuição

def foo_=(x: Int) { ... }

Sintaxe do espaço reservado

List(1, 2, 3) map (_ + 2)

Valores do método

List(1, 2, 3) foreach println _

Convertendo parâmetros de chamada por nome em funções

def toFunction(callByName: => Int): () => Int = callByName _

Inicializador padrão

var x: String = _   // unloved syntax may be eliminated

Pode haver outros que eu esqueci!

Exemplo mostrando o porquê foo(_)e foo _são diferentes:

Este exemplo vem de 0__ :

trait PlaceholderExample {
  def process[A](f: A => Unit)

  val set: Set[_ => Unit]

  set.foreach(process _) // Error 
  set.foreach(process(_)) // No Error
}

No primeiro caso, process _representa um método; Scala usa o método polimórfico e tenta torná-lo monomórfico preenchendo o parâmetro type, mas percebe que não há um tipo que possa ser preenchido para Aque dê o tipo (_ => Unit) => ?(Existential _não é um tipo).

No segundo caso, process(_)é um lambda; ao escrever um lambda sem nenhum tipo de argumento explícito, Scala deduz o tipo do argumento que foreachespera e _ => Unit é um tipo (enquanto simplesmente _não é), para que possa ser substituído e inferido.

Essa pode ser a pegadinha mais complicada de Scala que eu já encontrei.

Observe que este exemplo compila na 2.13. Ignore-o como se estivesse atribuído a sublinhado.

De (minha entrada) na FAQ , que certamente não garanto que esteja completa (adicionei duas entradas há apenas dois dias):

import scala._    // Wild card -- all of Scala is imported
import scala.{ Predef => _, _ } // Exception, everything except Predef
def f[M[_]]       // Higher kinded type parameter
def f(m: M[_])    // Existential type
_ + _             // Anonymous function placeholder parameter
m _               // Eta expansion of method into method value
m(_)              // Partial function application
_ => 5            // Discarded parameter
case _ =>         // Wild card pattern -- matches anything
val (a, _) = (1, 2) // same thing
for (_ <- 1 to 10)  // same thing
f(xs: _*)         // Sequence xs is passed as multiple parameters to f(ys: T*)
case Seq(xs @ _*) // Identifier xs is bound to the whole matched sequence
var i: Int = _    // Initialization to the default value
def abc_<>!       // An underscore must separate alphanumerics from symbols on identifiers
t._2              // Part of a method name, such as tuple getters
1_000_000         // Numeric literal separator (Scala 2.13+)

Isso também faz parte desta pergunta .

Uma excelente explicação dos usos do sublinhado é Scala _ [underscore] magic .

Exemplos:

 def matchTest(x: Int): String = x match {
     case 1 => "one"
     case 2 => "two"
     case _ => "anything other than one and two"
 }

 expr match {
     case List(1,_,_) => " a list with three element and the first element is 1"
     case List(_*)  => " a list with zero or more elements "
     case Map[_,_] => " matches a map with any key type and any value type "
     case _ =>
 }

 List(1,2,3,4,5).foreach(print(_))
 // Doing the same without underscore: 
 List(1,2,3,4,5).foreach( a => print(a))

No Scala, _age de maneira semelhante ao *Java ao importar pacotes.

// Imports all the classes in the package matching
import scala.util.matching._

// Imports all the members of the object Fun (static import in Java).
import com.test.Fun._

// Imports all the members of the object Fun but renames Foo to Bar
import com.test.Fun.{ Foo => Bar , _ }

// Imports all the members except Foo. To exclude a member rename it to _
import com.test.Fun.{ Foo => _ , _ }

No Scala, um getter e um setter serão implicitamente definidos para todos os vars não privados em um objeto. O nome do getter é igual ao nome da variável e _=é adicionado ao nome do setter.

class Test {
    private var a = 0
    def age = a
    def age_=(n:Int) = {
            require(n>0)
            a = n
    }
}

Uso:

val t = new Test
t.age = 5
println(t.age)

Se você tentar atribuir uma função a uma nova variável, a função será invocada e o resultado será atribuído à variável. Essa confusão ocorre devido aos colchetes opcionais para invocação de método. Devemos usar _ após o nome da função para atribuí-lo a outra variável.

class Test {
    def fun = {
        // Some code
    }
    val funLike = fun _
}

Há um uso que posso ver que todos aqui parecem ter esquecido de listar ...

Em vez de fazer isso:

List("foo", "bar", "baz").map(n => n.toUpperCase())

Você pode simplesmente fazer isso:

List("foo", "bar", "baz").map(_.toUpperCase())

Aqui estão mais alguns exemplos onde _é usado:

val nums = List(1,2,3,4,5,6,7,8,9,10)

nums filter (_ % 2 == 0)

nums reduce (_ + _)

nums.exists(_ > 5)

nums.takeWhile(_ < 8)

Nos exemplos acima, um sublinhado representa um elemento na lista (para reduzir o primeiro sublinhado representa o acumulador)

Além dos usos que JAiro mencionou, eu gosto deste:

def getConnectionProps = {
    ( Config.getHost, Config.getPort, Config.getSommElse, Config.getSommElsePartTwo )
}

Se alguém precisar de todas as propriedades da conexão, ele pode fazer:

val ( host, port, sommEsle, someElsePartTwo ) = getConnectionProps

Se você precisar de apenas um host e uma porta, poderá:

val ( host, port, _, _ ) = getConnectionProps

Há um exemplo específico que "_" seja usado:

  type StringMatcher = String => (String => Boolean)

  def starts: StringMatcher = (prefix:String) => _ startsWith prefix

pode ser igual a:

  def starts: StringMatcher = (prefix:String) => (s)=>s startsWith prefix

A aplicação de "_" em alguns cenários será automaticamente convertida em "(x $ n) => x $ n"