복붙노트

[SCALA] 스칼라의 상징적 사업자 모두가 무엇을 의미합니까?

SCALA

스칼라의 상징적 사업자 모두가 무엇을 의미합니까?

스칼라 구문은 문자를 많이 가지고있다. 이름 이러한 종류의 검색 엔진을 사용하여 찾기 어렵 기 때문에, 이들의 포괄적 인 목록 도움이 될 것입니다.

무엇 스칼라에서 모든 기호, 그리고 그들 각각의 기능은 무엇입니까?

특히, 나는에 대해 알고 싶습니다 -> || =, + =, <=, _._, ::, 및 : + =.

해결법

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

    1.나는 네 가지 범주로, 교육의 목적을 위해, 연산자를 분할 :

    나는 네 가지 범주로, 교육의 목적을 위해, 연산자를 분할 :

    그것은 대부분의 카테고리는 질문에 표현되어, 다음, 운이 :

    ->    // Automatically imported method
||=   // Syntactic sugar
++=   // Syntactic sugar/composition or common method
<=    // Common method
_._   // Typo, though it's probably based on Keyword/composition
::    // Common method
:+=   // Common method

    이러한 방법의 대부분의 정확한 의미를 정의하는 클래스에 따라 달라집니다. 예를 들어, <= 지능에가 "미만 또는 동등"를 의미한다. 첫 번째는, ->, 나는 아래의 예를 들어주지. :: 아마 (이 같은 이름의 객체가 될 수 있지만) 목록에 정의 된 방법이며, : + = 다양한 버퍼 클래스에 정의 된 방법은 아마이다.

    그래서, 그들을 볼 수 있습니다.

    특별 스칼라에서 일부 기호가 있습니다. 다른 사람들은 그냥 "예약"하는 동안 그들 중 두 적절한 키워드로 간주됩니다. 그들은:

    // Keywords
<-  // Used on for-comprehensions, to separate pattern from generator
=>  // Used for function types, function literals and import renaming

// Reserved
( )        // Delimit expressions and parameters
[ ]        // Delimit type parameters
{ }        // Delimit blocks
.          // Method call and path separator
// /* */   // Comments
#          // Used in type notations
:          // Type ascription or context bounds
<: >: <%   // Upper, lower and view bounds
<? <!      // Start token for various XML elements
" """      // Strings
'          // Indicate symbols and characters
@          // Annotations and variable binding on pattern matching
`          // Denote constant or enable arbitrary identifiers
,          // Parameter separator
;          // Statement separator
_*         // vararg expansion
_          // Many different meanings

    이 같은 제대로 같은 스칼라 사양 (PDF) 자체 언어를 설명 텍스트에서 찾을 수 있습니다, 언어의 일부입니다,하고.

    마지막으로 하나, 밑줄은이 널리 사용되기 때문에, 특별한 설명을받을 자격이, 그리고 많은 다른 의미가있다. 다음은 샘플입니다 :

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

    아마하지만, 다른 의미를 잊어 버렸습니다.

    당신이 위의 목록에서 찾고있는 기호를 찾지 못한 경우에 따라서, 그것은 방법, 또는 하나의 일부 여야합니다. 그러나, 종종, 당신은 몇 가지 기호와 클래스에 대한 내용은 해당 방법이 없습니다 볼 수 있습니다. 이 경우, 하나는 뭔가 다른, 또는 방법에 하나 이상의 방법의 조성보고있다가 범위로 ​​수입 또는 수입 암시 적 변환을 통해 볼 수있다.

    이들은 여전히 ​​ScalaDoc에서 찾을 수 있습니다 : 당신은 어디서 그들을 찾을 지 알아야합니다. 또는, 그 실패, 인덱스 (현재 야간에 2.9.1에 깨진 만 가능)를 봐주세요.

    모든 스칼라 코드는 세 자동 수입이있다 :

    // Not necessarily in this order
import _root_.java.lang._      // _root_ denotes an absolute path
import _root_.scala._
import _root_.scala.Predef._

    처음 두 단지 클래스와 싱글 톤 객체를 사용할 수 있도록. PREDEF은 개체 자체이기 때문에 세 번째는, 모든 암시 적 변환 및 수입 메서드가 포함되어 있습니다.

    PREDEF 내부 찾고 신속 일부 기호를 보여줍니다

    class <:<
class =:=
object <%<
object =:=

    다른 기호는 암시 적 변환을 통해 제공 될 것입니다. 그냥 매개 변수 방법을 수신하는 유형의 객체로받을 암시 태그 방법을 확인합니다. 예를 들면 :

    "a" -> 1  // Look for an implicit from String, AnyRef, Any or type parameter

    위의 경우, -> (A)가 동일한 방법에 바운드 형 파라미터 A 타입의 객체를 취하는 방법 any2ArrowAssoc 통해 클래스 ArrowAssoc 정의된다.

    그래서, 많은 기호는 단순히 클래스의 방법이 있습니다. 예를 들어, 당신이 할 경우

    List(1, 2) ++ List(3, 4)

    당신이 바로 목록에 대한 ScalaDoc에 ++ 방법을 찾을 수 있습니다. 그러나, 방법을 검색 할 때 당신이 알고 있어야 하나의 규칙이있다. 콜론으로 끝나는 방법 (왼쪽 대신 오른쪽에 결합 :). 즉, 상기 방법 호출 동안 동일하다 :

    List(1, 2).++(List(3, 4))

    내가 대신 1 : 목록이 있다면 (2, 3), 그에 해당 될 것이다 :

    List(2, 3).::(1)

    그래서 당신은 콜론으로 끝나는 방법을 찾을 때 오른쪽에있는 형 볼 필요가있다. 예를 들어, 고려 :

    1 +: List(2, 3) :+ 4

    첫 번째 방법 (+이 : 오른쪽으로 결합하고, 목록에 있습니다. 두 번째 방법 (+)는 단지 일반적인 방법이며, 왼쪽에 결합 - 다시 목록에.

    그래서, 여기에 방법을 숨길 수있는 몇 가지 구문 설탕입니다 :

    class Example(arr: Array[Int] = Array.fill(5)(0)) {
  def apply(n: Int) = arr(n)
  def update(n: Int, v: Int) = arr(n) = v
  def a = arr(0); def a_=(v: Int) = arr(0) = v
  def b = arr(1); def b_=(v: Int) = arr(1) = v
  def c = arr(2); def c_=(v: Int) = arr(2) = v
  def d = arr(3); def d_=(v: Int) = arr(3) = v
  def e = arr(4); def e_=(v: Int) = arr(4) = v
  def +(v: Int) = new Example(arr map (_ + v))
  def unapply(n: Int) = if (arr.indices contains n) Some(arr(n)) else None
}

val Ex = new Example // or var for the last example
println(Ex(0))  // calls apply(0)
Ex(0) = 2       // calls update(0, 2)
Ex.b = 3        // calls b_=(3)
// This requires Ex to be a "val"
val Ex(c) = 2   // calls unapply(2) and assigns result to c
// This requires Ex to be a "var"
Ex += 1         // substituted for Ex = Ex + 1

    어떤 상징적 인 방법을 그런 식으로 할당과 같은 방법을 형성하기 위해 결합 될 수 있기 때문에 마지막은 흥미 롭다.

    그리고 물론, 코드에 나타날 수있는 다양한 조합이있다 :

    (_+_) // An expression, or parameter, that is an anonymous function with
      // two parameters, used exactly where the underscores appear, and
      // which calls the "+" method on the first parameter passing the
      // second parameter as argument.
  2. ==============================

    2.스칼라와 다른 언어 사이 한 (좋은 IMO)의 차이는 거의 모든 문자와 방법의 이름을 할 수 있다는 것입니다.

    스칼라와 다른 언어 사이 한 (좋은 IMO)의 차이는 거의 모든 문자와 방법의 이름을 할 수 있다는 것입니다.

    당신이 열거하는 것은 "문장"하지만 평범하고 간단한 방법이 아니며, 같은 행동으로 (일부 규칙 있기는하지만) 하나의 개체에서 다른 다릅니다.

    예를 들어, 목록에 대한 Scaladoc 문서를 확인, 당신은 당신이 여기에 언급 된 몇 가지 방법을 확인할 수 있습니다.

    염두에 두어야 할 몇 가지 :

    당신은 스칼라 문서를 검색하여 대부분의 답을 찾을 수 있습니다. 여기에 대한 참조를 유지하는 노력을 중복 것, 그리고 신속하게 뒤 떨어지는 것입니다 :)

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

    3.당신은 그룹 그 첫 번째 몇 가지 기준에 따라 할 수 있습니다. 이 게시물에 난 그냥 밑줄 문자와 오른쪽 화살표를 설명합니다.

    당신은 그룹 그 첫 번째 몇 가지 기준에 따라 할 수 있습니다. 이 게시물에 난 그냥 밑줄 문자와 오른쪽 화살표를 설명합니다.

    _._는 기간이 포함되어 있습니다. 스칼라에서의 시간은 항상 메서드 호출을 나타냅니다. 그래서 당신은 수신기가 기간의 왼쪽, 그리고 메시지 (메소드 이름)의 권리. 이제 _ 스칼라의 특별한 상징이다. 그것에 대해 몇 가지 게시물은 모든 사용 사례이 블로그 항목, 예를 들어 있습니다. 여기가 익명 함수 지름길 즉, 하나 개의 인수를 받아 그것을 방법 _을 호출하는 기능의 바로 가기가된다. 이제 _ 올바른 방법이 아닙니다 그래서 가장 확실하게 당신이 _._ 1 또는 이와 유사한, 즉, 호출하는 방법을보고 하였다 함수 인수에 _._ 1. _1 _22에 튜플의 특정 요소를 추출 튜플의 방법이다. 예:

    val tup = ("Hallo", 33)
tup._1 // extracts "Hallo"
tup._2 // extracts 33

    이제 함수 응용 프로그램 바로 가기에 대한 사용 사례를 가정 할 수 있습니다. 문자열 정수를 매핑하는지도 감안할 때 :

    val coll = Map(1 -> "Eins", 2 -> "Zwei", 3 -> "Drei")

    Wooop은 이미 이상한 문장의 또 다른 발생이 있습니다. 하이픈 및 우측 화살표를 닮은보다 큰 자하는 Tuple2를 생성하는 연산자이다. 서면의 결과에 차이가없는 하나 (1, "고용주 식별 번호 (EIN)") 또는 1 -> "고용주 식별 번호 (EIN) ', 후자는 특히지도의 예와 같이 튜플의 목록에서 쉽게 읽을 수 만 있음. 더 -> 당신이 범위에서 객체 scala.Predef의 모든 암시 적 변환을 가지고 있기 때문에 가능한 몇 가지 다른 사업자처럼이며, 마법입니다. 여기에서 발생하는 변환입니다

    implicit def any2ArrowAssoc [A] (x: A): ArrowAssoc[A]

    Tuple2를 생성> 방법 - ArrowAssoc가있다 곳. 따라서, 1 -> "EIN 관련이"실제이다 호 Predef.any2ArrowAssoc (1) .-> ( "EIN 관련"). 승인. 이제 다시 밑줄 문자로 원래의 질문에 :

    // lets create a sequence from the map by returning the
// values in reverse.
coll.map(_._2.reverse) // yields List(sniE, iewZ, ierD)

    여기에 밑줄 다음 해당 코드를 단축 :

    coll.map(tup => tup._2.reverse)

    지도의지도 방법은 함수 인수에 키와 값의 튜플에 전달합니다. 우리는 값 (문자열)에만 관심이 있기 때문에, 우리는 튜플에 _2 방법으로 그들을 압축을 풉니 다.

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

    4.다니엘과 0__의 화려한 답변에 추가로, 그래서 대신에, 스칼라는 기호의 일부 유니 코드 유사체를 이해하는 말을

    다니엘과 0__의 화려한 답변에 추가로, 그래서 대신에, 스칼라는 기호의 일부 유니 코드 유사체를 이해하는 말을

    for (n <- 1 to 10) n % 2 match {
  case 0 => println("even")
  case 1 => println("odd")
}

    하나는 쓸 수 있습니다

    for (n ← 1 to 10) n % 2 match {
  case 0 ⇒ println("even")
  case 1 ⇒ println("odd")
}
  5. ==============================

    5.에 관한 :: :: 사건을 다루고 또 다른 유래의 항목이 있습니다. 즉, 'consing'헤드 소자와 테일리스트 목록을 생성하는 데 사용된다. 그것은 cons'ed 목록을 나타내고있는이 추출기로 사용할 수 있지만 가장 일반적으로이 목록의 방법은 클래스 모두이다. 이 콜론 만료 이후 파블로 페르난데스 지적한 바와 같이, 바로 연관 메소드 호출 수신기 오른쪽이고, 조작자의 좌측의 인수를 의미한다. 기존 목록에 새 헤드 요소를 붙이는 것처럼 우아하게 consing을 표현할 수있는 그런 식으로 :

    에 관한 :: :: 사건을 다루고 또 다른 유래의 항목이 있습니다. 즉, 'consing'헤드 소자와 테일리스트 목록을 생성하는 데 사용된다. 그것은 cons'ed 목록을 나타내고있는이 추출기로 사용할 수 있지만 가장 일반적으로이 목록의 방법은 클래스 모두이다. 이 콜론 만료 이후 파블로 페르난데스 지적한 바와 같이, 바로 연관 메소드 호출 수신기 오른쪽이고, 조작자의 좌측의 인수를 의미한다. 기존 목록에 새 헤드 요소를 붙이는 것처럼 우아하게 consing을 표현할 수있는 그런 식으로 :

    val x = 2 :: 3 :: Nil  // same result as List(2, 3)
val y = 1 :: x         // yields List(1, 2, 3)

    이것은 동일합니다

    val x = Nil.::(3).::(2) // successively prepend 3 and 2 to an empty list
val y = x.::(1)         // then prepend 1

    다음과 같이 추출 객체로 사용하는 것이다 :

    def extract(l: List[Int]) = l match {
   case Nil          => "empty"
   case head :: Nil  => "exactly one element (" + head + ")"
   case head :: tail => "more than one element"
}

extract(Nil)          // yields "empty"
extract(List(1))      // yields "exactly one element (33)"
extract(List(2, 3))   // yields "more than one element"

    이 여기 연산자처럼 보이는,하지만 정말 쓰기의 또 다른 (더 읽기) 방법입니다

    def extract2(l: List[Int]) = l match {
   case Nil            => "empty"
   case ::(head, Nil)  => "exactly one element (" + head + ")"
   case ::(head, tail) => "more than one element"
}

    이 게시물에 추출기에 대한 자세한 내용을보실 수 있습니다.

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

    6.<= 당신이 그것을 "읽기"하는 것과 같다 '보다 작거나 같다'. 그래서 수학 연산자는 목록에서의 <(미만?)> (보다 크다?) == (같음?)! = (같지 않은?) <=는 (이하인 ?), 및> = (이상인?).

    <= 당신이 그것을 "읽기"하는 것과 같다 '보다 작거나 같다'. 그래서 수학 연산자는 목록에서의 <(미만?)> (보다 크다?) == (같음?)! = (같지 않은?) <=는 (이하인 ?), 및> = (이상인?).

    이는 함수의 본체로부터 인수 목록을 구분하여 실행 몸에서 패턴 매칭의 시험 조건 (이 경우 블록)를 분리하는 데 사용되는 이중 오른쪽 화살표 종류이다> =과 혼동되지 않아야 일치가 발생합니다. 당신은 내 앞의 두 답변이의 예를 볼 수 있습니다. 첫째, 함수 사용 :

    coll.map(tup => tup._2.reverse)

    어떤 유형은 생략 이미 약기한다. 추적 기능이 될 것이다

    // function arguments         function body
(tup: Tuple2[Int, String]) => tup._2.reverse

    및 패턴 매칭을 사용 :

    def extract2(l: List[Int]) = l match {
   // if l matches Nil    return "empty"
   case Nil            => "empty"
   // etc.
   case ::(head, Nil)  => "exactly one element (" + head + ")"
   // etc.
   case ::(head, tail) => "more than one element"
}
  7. ==============================

    7.나는 현대 IDE가 큰 스칼라 프로젝트를 이해하는 데 중요하다고 생각. 이러한 연산자는 방법이기 때문에, 인 IntelliJ 생각에 난 그냥 Ctrl 키를 누른 채 클릭하고 정의로 또는 제어-B를.

    나는 현대 IDE가 큰 스칼라 프로젝트를 이해하는 데 중요하다고 생각. 이러한 연산자는 방법이기 때문에, 인 IntelliJ 생각에 난 그냥 Ctrl 키를 누른 채 클릭하고 정의로 또는 제어-B를.

    당신은 (오른쪽 단점 운영자로 제어 클릭 수 : :)와 말 스칼라의 javadoc에 결국 "이 목록의 시작 부분에 요소를 추가합니다." 그들은 암시가 정의 된 어디 IDE 알고 찾기 어려운 implicits ... 정의 될 수 있기 때문에 사용자 정의 사업자, 이것은, 더욱 중요하게된다.

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

    8.그냥 다른 훌륭한 답변에 추가. 스칼라는이 종종 비판을 상징적 연산자를 제공, / : (foldLeft) 및 : \ (foldRight) 사업자, 처음 인 오른쪽 연관. 그래서 다음과 같은 세 가지 명령문은 동일합니다

    그냥 다른 훌륭한 답변에 추가. 스칼라는이 종종 비판을 상징적 연산자를 제공, / : (foldLeft) 및 : \ (foldRight) 사업자, 처음 인 오른쪽 연관. 그래서 다음과 같은 세 가지 명령문은 동일합니다

    ( 1 to 100 ).foldLeft( 0, _+_ )
( 1 to 100 )./:( 0 )( _+_ )
( 0 /: ( 1 to 100 ) )( _+_ )

    이러한 세 가지가 있습니다 :

    ( 1 to 100 ).foldRight( 0, _+_ )
( 1 to 100 ).:\( 0 )( _+_ )
( ( 1 to 100 ) :\ 0 )( _+_ )
  9. ==============================

    9.스칼라는 자바의 산술 연산자의 대부분을 상속합니다. |이 비트 또는 포함 (단일 파이프 문자), 비트 단위 및, 비트 단위 배타적 논리합 ^뿐만 아니라 논리 (부울) 또는 || (두 파이프 문자) 및 논리 및 &&. 흥미롭게도, 당신은 부울에 단일 문자 연산자를 사용할 수 있습니다, 그래서 java'ish 논리 연산자는 완전히 중복 :

    스칼라는 자바의 산술 연산자의 대부분을 상속합니다. |이 비트 또는 포함 (단일 파이프 문자), 비트 단위 및, 비트 단위 배타적 논리합 ^뿐만 아니라 논리 (부울) 또는 || (두 파이프 문자) 및 논리 및 &&. 흥미롭게도, 당신은 부울에 단일 문자 연산자를 사용할 수 있습니다, 그래서 java'ish 논리 연산자는 완전히 중복 :

    true && true   // valid
true & true    // valid as well

3 & 4          // bitwise-and (011 & 100 yields 000)
3 && 4         // not valid

    또 다른 포스트에서 지적한 바와 같이, (! 그 이름을 가진 메소드가 존재하지 않는 경우) 해결 재 할당에 의해, 부호 = 등호로 끝나는 호출 :

    var x = 3
x += 1         // `+=` is not a method in `int`, Scala makes it `x = x + 1`

    이 '더블 체크'가 가능, 쉽게 불변의 컬렉션에 대한 변경 가능한을 교환 할 수 있습니다 :

    val m = collection.mutable.Set("Hallo")   // `m` a val, but holds mutable coll
var i = collection.immutable.Set("Hallo") // `i` is a var, but holds immutable coll

m += "Welt" // destructive call m.+=("Welt")
i += "Welt" // re-assignment i = i + "Welt" (creates a new immutable Set)

    10. from https://stackoverflow.com/questions/7888944/what-do-all-of-scalas-symbolic-operators-mean by cc-by-sa and MIT license

'SCALA' 카테고리의 다른 글

[SCALA] 스칼라에서 전체 파일을 읽기?  (0) 2019.10.31
[SCALA] 스칼라에서 적용되는 기능은 무엇입니까?  (0) 2019.10.31
[SCALA] 어떻게 스파크 SQL의 사용자 정의 유형에 대한 스키마를 정의?  (0) 2019.10.30
[SCALA] 스칼라로 돌아 가기  (0) 2019.10.30
[SCALA] 자바의 java.lang.Class <T> 객체의 스칼라 동등한  (0) 2019.10.30
,

티스토리툴바