Quelles sont toutes les utilisations d'un trait de soulignement à la Scala?

Question

J'ai pris un coup d'oeil à la liste des enquêtes pris sur scala-lang.org et a remarqué une curieuse question: "Pouvez-vous nommer tous les usages de "_"?". Pouvez-vous? Si oui, merci de le faire ici :-) exposé des exemples sont appréciés.

Answer 1

Celles que je peux penser sont

Existentielle types

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

Plus kinded paramètres de type

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

Ignoré des variables

val _ = 5

Ignoré des paramètres

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

Caractères génériques

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

Générique importations

import java.util._

Cacher les importations

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

Joindre des lettres de ponctuation

def bang_!(x: Int) = 5

Opérateurs d'affectation

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

Espace réservé syntaxe

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

Partiellement appliquée fonctions

List(1, 2, 3) foreach println _

Il y a peut être d'autres que j'ai oublié!

---

Exemple montrant pourquoi foo(_) et foo _ sont différentes:

Cet exemple provient de 0__:

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

  val set: Set[_ => Unit]

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

Dans le premier cas, process _ représente une méthode; Scala prend le polymorphe de la méthode et des tentatives de la rendre monomorphe, en remplissant le paramètre de type, mais se rend compte qu'il n'y a pas de type qui peut être rempli A que va donner le type (_ => Unit) => ? (Existentielle _ n'est pas un type).

Dans le second cas, process(_) est un lambda; lors de la rédaction d'un lambda sans argument explicite le type, la Scala déduit le type de l'argument de l' foreach attend, et _ => Unit est un type (alors que tout simplement _ n'est pas), de sorte qu'il peut être remplacé et involontaire.

C'est peut-être la plus délicate de la chasse aux sorcières dans Scala j'ai jamais rencontrées.

Answer 2

À partir de (mon entrée) dans la FAQ, je n'ai certainement pas de garantie pour être complet, j'ai ajouté deux entrées seulement il y a deux jours):

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

Cela fait aussi partie de cette question.

Answer 3

Une excellente explication de l'utilisation de l'underscore est Scala _ [soulignement] la magie.

Exemples:

 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(_))
 Do the same with underscore
 List(1,2,3,4,5).foreach( a => print(a))

En Scala, _ des actes semblables à * en Java lors de l'importation de paquets.

// 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 => _ , _ }

En Scala, un getter et setter sera implicitement définie pour tous les non-private var dans un objet. La lecture du nom est le même que le nom de la variable _= est ajouté pour le setter nom.

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

Utilisation: val t = new Test t.age = 5 println(t.l'âge)

Si vous essayez d'attribuer une fonction à une variable, la fonction sera appelée et le résultat sera affectée à la variable. Cette confusion se produit en raison de l'option d'accolades pour l'invocation de méthode. Nous devrions utiliser _ après le nom de la fonction à affecter à une autre variable.

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

Answer 4

Il y a l'utilisation, je peux voir tout le monde ici semble avoir oublié à la liste...

Plutôt que de faire ceci:

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

Vous pourriez peut simplement faire ceci:

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

Answer 5

Outre les usages que JAiro mentionné, j'aime celui-ci:

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

Si quelqu'un a besoin de toutes les propriétés de la connexion, il peut le faire:

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

Si vous avez juste besoin d'un hôte et un port, vous pouvez le faire:

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