[SCALA] 스칼라에서 밑줄의 모든 용도는 무엇입니까?

스칼라에서 밑줄의 모든 용도는 무엇입니까?

나는 scala-lang.org 촬영 설문 조사의 목록을 살펴본 호기심이 질문을 발견했습니다 : _ "당신의 모든 용도의 이름을 수" "?"를. 너는 할수 있니? 예 여기에 적어주십시오. 해설 예로 이해된다.

해결법

1. ==============================

   1.내가 생각할 수있는 사람은

   내가 생각할 수있는 사람은

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

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

   val _ = 5
   

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

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

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

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

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

   import java.util._
   

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

   def bang_!(x: Int) = 5
   

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

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

   List(1, 2, 3) foreach println _
   

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

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

   내가 잊어 버린 사람이있을 수 있습니다!

   왜 foo는 (_) 및 foo는 _ 다른를 보여주는 예 :

   이 예는 0__에서 온다 :

   trait PlaceholderExample {
     def process[A](f: A => Unit)
   
     val set: Set[_ => Unit]
   
     set.foreach(process _) // Error 
     set.foreach(process(_)) // No Error
   }
   

   첫 번째 경우, 처리는 _ 방법을 나타내고; 스칼라 다형성 방법을 취하고 입력 파라미터로 작성하여 그것을 단형을 시도하지만, 타입 (_ => 단위) =>을 줄 것이라는 대해 채워질 수있는 유형이 없다는 것을 알게? (실존 _ 유형 아니다).

   후자의 경우, 프로세스 (_)의 람다이고; 명시적인 인수 유형 람다를 작성할 때, 스칼라의 foreach 예상하는 인수의 타입을 추론하고 _ => 유닛 타입이다 (반면 평범한 _ 아니다)가 치환 될 수 있도록 추론.

   이것은 물론 내가 지금까지 발생했습니다 스칼라에서 가장 까다로운 잡았다 될 수있다.

   이 예는 2.13에 컴파일합니다. 이를 강조하기 위해 할당 된 것처럼 무시합니다.

2. ==============================

   2.나는 확실히 완전 보장하지 않는 자주 묻는 질문에 (내 항목)에서 (난 그냥 이틀 전에 두 개의 항목을 추가)

   나는 확실히 완전 보장하지 않는 자주 묻는 질문에 (내 항목)에서 (난 그냥 이틀 전에 두 개의 항목을 추가)

   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+)
   

   이것은 또한이 질문의 일부입니다.

3. ==============================

   3.밑줄의 용도로 잘 설명 스칼라 _ [밑줄] 마법이다.

   밑줄의 용도로 잘 설명 스칼라 _ [밑줄] 마법이다.

   예를 들면 :

    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))
   

   패키지를 가져 오는 동안 스칼라에서 _ 자바 *와 비슷한 역할을합니다.

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

   스칼라에서는 getter 및 setter는 암시 적으로 객체의 모든 비 개인 바르에 대해 정의됩니다. 게터 이름 변수 이름과 동일하고 _ = 세터 이름을 첨가한다.

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

   용법:

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

   새 변수에 기능을 할당하려고하면, 함수가 호출되고 결과는 변수에 할당됩니다. 이 혼란으로 인해 메서드 호출에 대한 선택적 괄호에 발생합니다. 우리는 다른 변수에 할당 함수 이름 뒤에 _ 사용해야합니다.

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

4. ==============================

   4.내가 여기에 모두 나열 할 수 잊어 버린 것 같다 볼 수있는 하나 개의 사용이 있습니다 ...

   내가 여기에 모두 나열 할 수 잊어 버린 것 같다 볼 수있는 하나 개의 사용이 있습니다 ...

   오히려이 일을보다 :

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

   당신은 단순히이 작업을 수행 할 수 있었다 :

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

5. ==============================

   5.여기에 _를 사용하는 몇 가지 더 예입니다 :

   여기에 _를 사용하는 몇 가지 더 예입니다 :

   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)
   

   모든 전술 한 실시 예에서, 밑줄 (제 밑줄을 감소하는 어큐뮬레이터를 나타내는 경우) 목록의 원소를 나타내고

6. ==============================

   6.하이로 언급 한 용도 외에, 나는이 일을 좋아한다 :

   하이로 언급 한 용도 외에, 나는이 일을 좋아한다 :

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

   누군가가 모든 연결 속성을 필요로하는 경우, 그는 수행 할 수 있습니다 :

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

   그냥 호스트와 포트를해야 할 경우, 당신은 할 수 있습니다 :

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

7. ==============================

   7.

   import scala._    // Wild card -- all of Scala is imported
   
   import scala.{ Predef => _, _ } // Exclusion, 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
   
   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
   
   Please check the below link for more details
   
   [https://docs.scala-lang.org/tutorials/FAQ/finding-symbols.html][1]
   

8. ==============================

   8."_"를 사용하는 것이 구체적인 예는있다 :

   "_"를 사용하는 것이 구체적인 예는있다 :

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

   동일 할 수있다 :

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

   자동으로 변환하는 몇 가지 시나리오에서 "_"적용 "(X의 $의 N) => X $ n을"

from https://stackoverflow.com/questions/8000903/what-are-all-the-uses-of-an-underscore-in-scala by cc-by-sa and MIT license