human
J'ai jeté un coup d'œil à la liste des enquêtes réalisées sur scala-lang.org et j'ai remarqué une question curieuse : "Pouvez-vous nommer toutes les utilisations de “_” ?". Pouvez-vous le faire ? Si oui, veuillez le faire ici. Des exemples explicatifs sont appréciés
gpt
Ce qui suit est une explication des utilisations du tiret bas en Scala _ [underscore] magique.
Exemples :
``` def matchTest(x: Int): String = x match {
     case 1 => "un"
     case 2 => "deux"
     case _ => "tout autre chose que un et deux"
 }
 expr match {
     case List(1,_,_) => "une liste avec trois éléments et le premier élément est 1"
     case List(_*)  => "une liste avec zéro ou plusieurs éléments"
     case Map[_,_] => "correspond à une carte avec n'importe quel type de clé et n'importe quel type de valeur"
     case _ =>
 }
 List(1,2,3,4,5).foreach(print(_))
 // Faire la même chose sans tiret bas :
 List(1,2,3,4,5).foreach( a => print(a))
```
En Scala, ```_``` agit de manière similaire à ```*``` en Java lors de l'importation de packages.
```// Importe toutes les classes du package correspondant
import scala.util.matching._
// Importe tous les membres de l'objet Fun (importation statique en Java).
import com.test.Fun._
// Importe tous les membres de l'objet Fun mais renomme Foo en Bar
import com.test.Fun.{ Foo => Bar , _ }
// Importe tous les membres sauf Foo. Pour exclure un membre, le renommer en _
import com.test.Fun.{ Foo => _ , _ }
```
En Scala, un getter et un setter seront implicitement définis pour toutes les variables non privées dans un objet. Le nom du getter est identique au nom de la variable et ```_=``` est ajouté pour le nom du setter.
```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.age)
```
Si vous essayez d'assigner une fonction à une nouvelle variable, la fonction sera invoquée et le résultat sera assigné à la variable. Cette confusion est due aux accolades optionnelles pour l'invocation de méthode. Nous devons utiliser _ après le nom de la fonction pour l'assigner à une autre variable.
```class Test {
    def fun = {
        // Some code
    }
    val funLike = fun _
}
```