Bazı Scala kodu okuma, dil öğrenmeye çalışıyorum ve ben kodu anlamak kendisi ve bazı karşıdan karşıya geliyor devam ediyorum işler yapan bir noktalama işareti anlamsız. Sorun değil hemen hemen imkansız bir noktalama işareti için herhangi bir arama motoru arama - tüm sorgu işlenmiş ulaşmadan önce filtrelenir.

Bu herhangi bir tek belge bulamadım gerçeği ile birleşir Scala kolay gibi görünüyor hepsi deli kısayolları özetliyor yol.

Ya da daha iyisi yazmak, böyle bir rehber için bana gösterebilir misin? Sadece bir yorum, sayfa veya noktalama listesi ile blog yazı ve HTML belgesi şeyi yapar. Özellikle, hakkında kafam karıştı:

 ->
 ||=
   =
 <=
 _._
 ::
 : =

Operatörler, öğretim amaçlı, içine bölündört kategoride:

• Anahtar kelimeler/semboller saklıdır
• Otomatik olarak alınan yöntemler
• Ortak yöntemleri
• Cümle bilgisi/bileşimi şekerler

En kategoriler soruyu temsil edilen, daha sonra şanslı

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

Bu yöntemlerden en kesin anlamını tanımlayarak sınıf bağlıdır. , <= Int anlamına gelir örneğin< . em ^"küçük veya eşit". İlki, -> örnek olarak aşağıda vereceğim. :: muhtemelen yöntemi List (olsa . tanımlanır ^em>olabiliraynı adı taşıyan nesne) ve : = muhtemelen yöntemi Buffer çeşitli sınıflar tanımlanır.

Bu yüzden, onları görmek istiyorum.

Anahtar kelimeler/semboller saklıdır

Özel olan Scala bazı semboller vardır. Diğerleri ise sadece uygun anahtar kelimeler olarak, iki "" ayrılmış. Bunlar:

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

Bunların hepsidilinin bir parçasıve, gibi, düzgün dili, Scala Specification(PDF) kendisi gibi açıklayan herhangi bir metin bulunabilir.

Sonuncusu, alt çizgi, yaygın olarak kullanılır, çünkü özel bir açıklama hak ediyorum, ve çok farklı anlamları vardır. İşte bir örnek:

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

Ben muhtemelen başka bir anlamı olsa da unuttu.

Otomatik olarak alınan yöntemler

Eğer yukarıdaki listede aradığınız sembol bulsaydın değil, bir yöntem ya da bir parçası olmalı. Ama, sık sık, bazı sembol göreceksiniz ve sınıfı belgelerine bu yöntem olmaz. Bu durumda, ya da başka bir şey ile bir veya daha fazla yöntem bir kompozisyon arıyoruz, ya da yöntemi kapsamı içine alınmış veya ithal örtülü bir dönüşüm yoluyla kullanılabilir.

Buhala bulunabilirScalaDoc: sadece onlara bakmak için bilmek zorunda. Veya bir hata vardır, index (şu anda 2.9.1 ama gece mevcut kırık) bak.

Her Scala kod üç otomatik ithalat

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

İlk iki tek sınıf ve tek nesneleri kullanılabilir hale getirmek. Üçüncüsü Predef bir nesnenin kendisi olduğu için örtülü dönüşüm ve ithal edilen tüm yöntemleri içerir.

Predef içine bakarak hızlı bir şekilde bazı simgeler göster:

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

Başka bir sembol ile sunulacaktırörtük dönüştürme. Bu yöntem parametre olarak almak implicit ile etiketlenmiş bak yöntemi alan türde bir nesne sadece. Örneğin:

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

Yukarıdaki durumda, -> tanımlanmış sınıf ArrowAssoc yöntemi any2ArrowAssoc Bu alır bir nesne türü A nereye A sınırlandırılmamış tür parametresi için aynı yöntem.

Ortak yöntemleri

Bu yüzden, birçok sembol sadece bir sınıf yöntemleri vardır. Eğer bunu yaparsanız mesela

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

List ScalaDoc yöntemi doğru bulabilirsiniz. Ancak, yöntemleri ararken farkında olması gereken bir kongre var. Yöntem kolon (:) biten bağlamakdoğrusol yerine. Yukarıdaki yöntem çağrısı denk gelirken, diğer bir deyişle,:

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

Eğer olsaydı, bunun yerine 1 :: List(2, 3), eşdeğer olacaktır:

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

Tür bakmak gerekirsağ taraftayöntem kolon biten ararken. Düşünün, örneğin:

1  : List(2, 3) :  4

İlk yöntem (**40) doğru bağlanır, List üzerinde bulundu. İkinci yöntem (: ) sadece normal bir yöntem ve sol yine List bağlar.

Cümle bilgisi/bileşimi şekerler

Yani, burada bir yöntem gizlemek olabilir birkaç cümle bir şeker:

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
}

var ex = new Example
println(ex(0))  // calls apply(0)
ex(0) = 2       // calls update(0, 2)
ex.b = 3        // calls b_=(3)
val ex(c) = 2   // calls unapply(2) and assigns result to c
ex  = 1         // substituted for ex = ex   1

Son bir ilginç, çünküherhangi birsembolik yöntem atama gibi bir yöntem bu şekilde oluşturmak için kombine edilebilir.

Ve, tabii ki, kod görülebilen çeşitli kombinasyonları var:

(_ _) // 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.