出于教学目的，我将运算符分为四类：
- 关键字/保留符号
- 自动导入方法
- 常用方法
- 语法糖/成分
幸运的是，问题中代表了大多数类别：
-> // 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
这些方法大多数的确切含义取决于定义它们的类。例如，<=on Int表示“小于或等于”。第一个，->我将在下面给出示例。::可能是在其上定义的方法List（尽管它可能是同名对象），并且:+=可能是在各种Buffer类上定义的方法。
所以，让我们看看他们。
关键字/保留符号
Scala中有一些特殊的符号。其中两个被认为是适当的关键字，而其他两个仅被“保留”。他们是：
// 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
这些都是语言的一部分，因此，可以在正确描述该语言的任何文本中找到它们，例如Scala Specification（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上已断开，但每晚可用）。
每个Scala代码都有三个自动导入：
// 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 =:=
任何其他符号都可以通过隐式转换获得。只需查看标记有该方法的方法，该方法将implicit接收该方法的类型的对象作为参数接收。例如：
"a" -> 1 // Look for an implicit from String, AnyRef, Any or type parameter
在上述情况下，->是ArrowAssoc通过any2ArrowAssoc采用类型为的对象的方法在类中定义的A，其中A是同一方法的无界类型参数。
常用方法
因此，许多符号仅仅是类上的方法。例如，如果您这样做
List(1, 2) ++ List(3, 4)
您可以在++ScalaDoc for List上找到该方法。但是，在搜索方法时必须注意一种约定。以冒号（:）结尾的方法绑定到右侧而不是左侧。换句话说，虽然上面的方法调用等效于：
List(1, 2).++(List(3, 4))
如果有，1 :: List(2, 3)那将等效于：
List(2, 3).::(1)
因此，在查找以冒号结尾的方法时，您需要查看右侧找到的类型。考虑例如：
1 +: List(2, 3) :+ 4
第一个方法（+:）绑定到右侧，并在上找到List。第二种方法（:+）只是普通方法，并绑定到左侧-再次List。
语法糖/成分
因此，这里有一些语法糖可能会隐藏方法：
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.