Scala 的所有符号运算符是什么意思？

Question

Scala 语法有很多符号。由于使用搜索引擎很难找到这些类型的名称，因此完整的列表会很有帮助。

Scala 中的所有符号是什么？它们各自的作用是什么？

我特别想了解 ->、||=、++=、<=< /code>、_._、:: 和 :+=。

Answer 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

大多数这些方法的确切含义取决于定义它们的类。例如，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 规范(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 通过采用 A 类型对象的方法 any2ArrowAssoc，其中 A 是一个同一方法的无界类型参数。

常见方法

因此，许多符号只是类上的方法。例如，如果您这样做，

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

您将在 ScalaDoc 上找到 列表。但是，在搜索方法时必须注意一个约定。以冒号 (:) 结尾的方法将绑定到右侧而不是左侧。换句话说，虽然上面的方法调用相当于：

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.

Answer 2

Scala 与其他语言之间的一个（良好的，IMO）区别是它允许您使用几乎任何字符来命名您的方法。

您列举的不是“标点符号”，而是简单明了的方法，因此它们的行为因一个对象而异（尽管有一些约定）。

例如，查看 List 的 Scaladoc 文档 ，您将看到此处提到的一些方法。

需要记住的一些事情：

• 大多数情况下，A 运算符+等于 B 组合会转换为 A = A 运算符 B，如 | 中所示。 |= 或 ++= 示例。

• 以 : 结尾的方法是右关联的，这意味着 A :: B 实际上是 B.::(A)。

您可以通过浏览 Scala 文档找到大多数答案。在这里保留参考会重复工作，而且很快就会落后:)

Answer 3

您可以首先根据某些标准对它们进行分组。在这篇文章中，我将仅解释下划线字符和右箭头。

_._ 包含句点。 Scala 中的句点始终表示方法调用。因此，句点的左侧是接收者，右侧是消息（方法名称）。现在 _ 是 Scala 中的一个特殊符号。有几篇关于它的文章，例如 此博客条目< /a> 所有用例。这里它是一个匿名函数快捷方式，即它是一个函数的快捷方式，该函数接受一个参数并调用其方法_。现在 _ 不是有效的方法，因此您肯定会看到 _._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, "Eins") 或 1 -> 的结果没有区别。 “Eins”，只是后者更容易阅读，尤其是在像地图示例这样的元组列表中。 -> 并不神奇，它像其他一些运算符一样可用，因为您在对象 scala.Predef 在范围内。这里发生的转换是

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

ArrowAssoc 具有创建 Tuple2 的 -> 方法。因此 1 -> “Eins”实际是调用Predef.any2ArrowAssoc(1).->(“Eins”)。好的。现在回到带有下划线字符的原始问题：

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

请注意，Map 的 map 方法将键和值的元组传递给函数参数。由于我们只对值（字符串）感兴趣，因此我们使用元组上的 _2 方法提取它们。

Answer 4

作为 Daniel 和 0__ 精彩答案的补充，我不得不说 Scala 理解 Unicode 类似物一些符号，因此

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

Answer 5

关于 :: 还有另一个 Stackoverflow 条目涵盖了 :: 案例。简而言之，它用于通过“consing”头元素和尾列表来构造列表。它既是一个 类< /em> 表示一个 cons'ed 列表，可以用作提取器，但最常见的是它是列表上的方法。正如 Pablo Fernandez 指出的那样，由于它以冒号结尾，因此它是右结合，这意味着方法调用的接收者在右侧，参数在运算符的左侧。这样你就可以优雅地将 consing 表达为在现有列表中添加一个新的 head 元素：

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 (1)"
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"
}

您可以在这篇文章中阅读有关提取器的更多信息。

Answer 6

<= 就像您“阅读”它一样：“小于或等于”。所以它是一个数学运算符，在<（小于？）、>（大于？）、==（等于？）、!=（不等于？）、<=（小于或等于？）和 >=（大于或等于？）。

这不能与 => 混淆，后者是一种双右手箭头，用于将参数列表与正文分开函数的一部分，并将模式匹配中的测试条件（一个 case 块）与匹配发生时执行的主体分开。你可以在我之前的两个答案中看到这个例子。首先，函数 use:

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

Answer 7

只是添加到其他优秀答案中。 Scala 提供了两个经常被批评的符号运算符，/: (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 )( _+_ )

Answer 8

我认为现代 IDE 对于理解大型 scala 项目至关重要。由于这些运算符也是方法，因此在 intellij idea 中我只需按住 Control 键单击或按 Control-B 键进入定义。

您可以按住 Control 键并右键单击 cons 运算符 (::)，最后会出现 scala javadoc，显示“在此列表的开头添加一个元素”。在用户定义的运算符中，这变得更加重要，因为它们可以在难以找到的隐式中定义......您的 IDE 知道隐式是在哪里定义的。

Answer 9

Scala 继承了大部分 Java 算术运算符。这包括按位或 | （单管道字符）、按位与 &、按位异或 ^ 以及逻辑（布尔值）或 || （两个管道字符）和逻辑与 &&。有趣的是，您可以在 boolean 上使用单字符运算符，因此 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)

Answer 10

哦哦，所以你想要一个详尽的答案吗？这是一个有趣的、希望完整的、相当长的列表给你:)

http://jim-mcbeath.blogspot.com/2008/12/scala-operator-cheat-sheet.html

（免责声明 - 该帖子是写于 2008 年，所以可能有点过时了）

!! AbstractActor
!! Actor // Sends msg to this actor and immediately ...
!! Proxy
! Actor // Sends msg to this actor (asynchronous).
! Channel // Sends a message to this Channel.
! OutputChannel // Sends msg to this ...
! Proxy // Sends msg to this ...
!= Any // o != arg0 is the same as !(o == (arg0)).
!= AnyRef
!= Boolean
!= Byte
!= Char
!= Double
!= Float
!= Int
!= Long
!= Short
!? AbstractActor
!? Actor // Sends msg to this actor and awaits reply ...
!? Channel // Sends a message to this Channel and ...
!? Proxy
% BigInt // Remainder of BigInts
% Byte
% Char
% Double
% Float
% Int
% Long
% Short
% Elem // Returns a new element with updated attributes, resolving namespace uris from this element's scope. ...
&&& Parsers.Parser
&& Boolean
&+ NodeBuffer // Append given object to this buffer, returns reference on this NodeBuffer ...
& BigInt // Bitwise and of BigInts
& Boolean
& Byte
& Char
& Enumeration.Set32 // Equivalent to * for bit sets. ...
& Enumeration.Set64 // Equivalent to * for bit sets. ...
& Enumeration.SetXX // Equivalent to * for bit sets. ...
& Int
& Long
& Short
&~ BigInt // Bitwise and-not of BigInts. Returns a BigInt whose value is (this & ~that).
&~ Enumeration.Set32 // Equivalent to - for bit sets. ...
&~ Enumeration.Set64 // Equivalent to - for bit sets. ...
&~ Enumeration.SetXX // Equivalent to - for bit sets. ...
>>> Byte
>>> Char
>>> Int
>>> Long
>>> Short
>> BigInt // (Signed) rightshift of BigInt
>> Byte
>> Char
>> Int
>> Long
>> Short
>> Parsers.Parser // Returns into(fq)
>> Parsers.Parser // Returns into(fq)
> BigDecimal // Greater-than comparison of BigDecimals
> BigInt // Greater-than comparison of BigInts
> Byte
> Char
> Double
> Float
> Int
> Long
> Ordered
> PartiallyOrdered
> Short
>= BigDecimal // Greater-than-or-equals comparison of BigDecimals
>= BigInt // Greater-than-or-equals comparison of BigInts
>= Byte
>= Char
>= Double
>= Float
>= Int
>= Long
>= Ordered
>= PartiallyOrdered
>= Short
<< BigInt // Leftshift of BigInt
<< Byte
<< Char
<< Int
<< Long
<< Short
<< Buffer // Send a message to this scriptable object.
<< BufferProxy // Send a message to this scriptable object.
<< Map // Send a message to this scriptable object.
<< MapProxy // Send a message to this scriptable object.
<< Scriptable // Send a message to this scriptable object.
<< Set // Send a message to this scriptable object.
<< SetProxy // Send a message to this scriptable object.
<< SynchronizedBuffer // Send a message to this scriptable object.
<< SynchronizedMap // Send a message to this scriptable object.
<< SynchronizedSet // Send a message to this scriptable object.
< BigDecimal // Less-than of BigDecimals
< BigInt // Less-than of BigInts
< Byte
< Char
< Double
< Float
< Int
< Long
< Ordered
< PartiallyOrdered
< Short
< OffsetPosition // Compare this position to another, by first comparing their line numbers, ...
< Position // Compare this position to another, by first comparing their line numbers, ...
<= BigDecimal // Less-than-or-equals comparison of BigDecimals
<= BigInt // Less-than-or-equals comparison of BigInts
<= Byte
<= Char
<= Double
<= Float
<= Int
<= Long
<= Ordered
<= PartiallyOrdered
<= Short
<~ Parsers.Parser // A parser combinator for sequential composition which keeps only the left result
** Enumeration.SetXX
** Set // Intersect. It computes an intersection with set that. ...
** Set // This method is an alias for intersect. ...
* BigDecimal // Multiplication of BigDecimals
* BigInt // Multiplication of BigInts
* Byte
* Char
* Double
* Float
* Int
* Long
* Short
* Set
* RichString // return n times the current string
* Parsers.Parser // Returns a parser that repeatedly parses what this parser parses, interleaved with the `sep' parser. ...
* Parsers.Parser // Returns a parser that repeatedly parses what this parser parses
* Parsers.Parser // Returns a parser that repeatedly parses what this parser parses, interleaved with the `sep' parser. ...
* Parsers.Parser // Returns a parser that repeatedly parses what this parser parses, interleaved with the `sep' parser.
* Parsers.Parser // Returns a parser that repeatedly parses what this parser parses
++: ArrayBuffer // Prepends a number of elements provided by an iterable object ...
++: Buffer // Prepends a number of elements provided by an iterable object ...
++: BufferProxy // Prepends a number of elements provided by an iterable object ...
++: SynchronizedBuffer // Prepends a number of elements provided by an iterable object ...
++ Array // Returns an array consisting of all elements of this array followed ...
++ Enumeration.SetXX
++ Iterable // Appends two iterable objects.
++ IterableProxy // Appends two iterable objects.
++ Iterator // Returns a new iterator that first yields the elements of this ...
++ List // Appends two list objects.
++ RandomAccessSeq // Appends two iterable objects.
++ RandomAccessSeqProxy // Appends two iterable objects.
++ Seq // Appends two iterable objects.
++ SeqProxy // Appends two iterable objects.
++ IntMap // Add a sequence of key/value pairs to this map.
++ LongMap // Add a sequence of key/value pairs to this map.
++ Map // Add a sequence of key/value pairs to this map.
++ Set // Add all the elements provided by an iterator ...
++ Set // Add all the elements provided by an iterator to the set.
++ SortedMap // Add a sequence of key/value pairs to this map.
++ SortedSet // Add all the elements provided by an iterator ...
++ Stack // Push all elements provided by the given iterable object onto ...
++ Stack // Push all elements provided by the given iterator object onto ...
++ TreeHashMap
++ TreeHashMap // Add a sequence of key/value pairs to this map.
++ Collection // Operator shortcut for addAll.
++ Set // Operator shortcut for addAll.
++ ArrayBuffer // Appends two iterable objects.
++ Buffer // Appends a number of elements provided by an iterable object ...
++ Buffer // Appends a number of elements provided by an iterator ...
++ Buffer // Appends two iterable objects.
++ BufferProxy // Appends a number of elements provided by an iterable object ...
++ Map // Add a sequence of key/value pairs to this map.
++ MapProxy // Add a sequence of key/value pairs to this map.
++ PriorityQueue
++ Set // Add all the elements provided by an iterator ...
++ SynchronizedBuffer // Appends a number of elements provided by an iterable object ...
++ RichString // Appends two iterable objects.
++ RichStringBuilder // Appends a number of elements provided by an iterable object ...
++ RichStringBuilder // Appends two iterable objects.
++= Map // Add a sequence of key/value pairs to this map.
++= MapWrapper // Add a sequence of key/value pairs to this map.
++= ArrayBuffer // Appends a number of elements in an array
++= ArrayBuffer // Appends a number of elements provided by an iterable object ...
++= ArrayStack // Pushes all the provided elements onto the stack.
++= Buffer // Appends a number of elements in an array
++= Buffer // Appends a number of elements provided by an iterable object ...
++= Buffer // Appends a number of elements provided by an iterator
++= BufferProxy // Appends a number of elements provided by an iterable object ...
++= Map // Add a sequence of key/value pairs to this map.
++= MapProxy // Add a sequence of key/value pairs to this map.
++= PriorityQueue // Adds all elements provided by an Iterable object ...
++= PriorityQueue // Adds all elements provided by an iterator into the priority queue.
++= PriorityQueueProxy // Adds all elements provided by an Iterable object ...
++= PriorityQueueProxy // Adds all elements provided by an iterator into the priority queue.
++= Queue // Adds all elements provided by an Iterable object ...
++= Queue // Adds all elements provided by an iterator ...
++= QueueProxy // Adds all elements provided by an Iterable object ...
++= QueueProxy // Adds all elements provided by an iterator ...
++= Set // Add all the elements provided by an iterator ...
++= SetProxy // Add all the elements provided by an iterator ...
++= Stack // Pushes all elements provided by an Iterable object ...
++= Stack // Pushes all elements provided by an iterator ...
++= StackProxy // Pushes all elements provided by an Iterable object ...
++= StackProxy // Pushes all elements provided by an iterator ...
++= SynchronizedBuffer // Appends a number of elements provided by an iterable object ...
++= SynchronizedMap // Add a sequence of key/value pairs to this map.
++= SynchronizedPriorityQueue // Adds all elements provided by an Iterable object ...
++= SynchronizedPriorityQueue // Adds all elements provided by an iterator into the priority queue.
++= SynchronizedQueue // Adds all elements provided by an Iterable object ...
++= SynchronizedQueue // Adds all elements provided by an iterator ...
++= SynchronizedSet // Add all the elements provided by an iterator ...
++= SynchronizedStack // Pushes all elements provided by an Iterable object ...
++= SynchronizedStack // Pushes all elements provided by an iterator ...
++= RichStringBuilder // Appends a number of elements provided by an iterable object ...
+: ArrayBuffer // Prepends a single element to this buffer and return ...
+: Buffer // Prepend a single element to this buffer and return ...
+: BufferProxy // Prepend a single element to this buffer and return ...
+: ListBuffer // Prepends a single element to this buffer. It takes constant ...
+: ObservableBuffer // Prepend a single element to this buffer and return ...
+: SynchronizedBuffer // Prepend a single element to this buffer and return ...
+: RichStringBuilder // Prepend a single element to this buffer and return ...
+: BufferWrapper // Prepend a single element to this buffer and return ...
+: RefBuffer // Prepend a single element to this buffer and return ...
+ BigDecimal // Addition of BigDecimals
+ BigInt // Addition of BigInts
+ Byte
+ Char
+ Double
+ Enumeration.SetXX // Create a new set with an additional element.
+ Float
+ Int
+ List
+ Long
+ Short
+ EmptySet // Create a new set with an additional element.
+ HashSet // Create a new set with an additional element.
+ ListSet.Node // This method creates a new set with an additional element.
+ ListSet // This method creates a new set with an additional element.
+ Map
+ Map // Add a key/value pair to this map.
+ Map // Add two or more key/value pairs to this map.
+ Queue // Creates a new queue with element added at the end ...
+ Queue // Returns a new queue with all all elements provided by ...
+ Set // Add two or more elements to this set.
+ Set // Create a new set with an additional element.
+ Set1 // Create a new set with an additional element.
+ Set2 // Create a new set with an additional element.
+ Set3 // Create a new set with an additional element.
+ Set4 // Create a new set with an additional element.
+ SortedMap // Add a key/value pair to this map.
+ SortedMap // Add two or more key/value pairs to this map.
+ SortedSet // Create a new set with an additional element.
+ Stack // Push all elements provided by the given iterable object onto ...
+ Stack // Push an element on the stack.
+ TreeSet // A new TreeSet with the entry added is returned,
+ Buffer // adds "a" from the collection. Useful for chaining.
+ Collection // adds "a" from the collection. Useful for chaining.
+ Map // Add a key/value pair to this map.
+ Set // adds "a" from the collection. Useful for chaining.
+ Buffer // Append a single element to this buffer and return ...
+ BufferProxy // Append a single element to this buffer and return ...
+ Map // Add a key/value pair to this map.
+ Map // Add two or more key/value pairs to this map.
+ MapProxy // Add a key/value pair to this map.
+ MapProxy // Add two or more key/value pairs to this map.
+ ObservableBuffer // Append a single element to this buffer and return ...
+ PriorityQueue
+ Set // Add a new element to the set.
+ Set // Add two or more elements to this set.
+ SynchronizedBuffer // Append a single element to this buffer and return ...
+ Parsers.Parser // Returns a parser that repeatedly (at least once) parses what this parser parses.
+ Parsers.Parser // Returns a parser that repeatedly (at least once) parses what this parser parses.
+= Collection // adds "a" from the collection.
+= Map // Add a key/value pair to this map.
+= ArrayBuffer // Appends a single element to this buffer and returns ...
+= ArrayStack // Alias for push.
+= BitSet // Sets i-th bit to true. ...
+= Buffer // Append a single element to this buffer.
+= BufferProxy // Append a single element to this buffer.
+= HashSet // Add a new element to the set.
+= ImmutableSetAdaptor // Add a new element to the set.
+= JavaSetAdaptor // Add a new element to the set.
+= LinkedHashSet // Add a new element to the set.
+= ListBuffer // Appends a single element to this buffer. It takes constant ...
+= Map // Add a key/value pair to this map.
+= Map // Add two or more key/value pairs to this map.
+= Map // This method defines syntactic sugar for adding or modifying ...
+= MapProxy // Add a key/value pair to this map.
+= MapProxy // Add two or more key/value pairs to this map.
+= ObservableSet // Add a new element to the set.
+= PriorityQueue // Add two or more elements to this set.
+= PriorityQueue // Inserts a single element into the priority queue.
+= PriorityQueueProxy // Inserts a single element into the priority queue.
+= Queue // Inserts a single element at the end of the queue.
+= QueueProxy // Inserts a single element at the end of the queue.
+= Set // Add a new element to the set.
+= Set // Add two or more elements to this set.
+= SetProxy // Add a new element to the set.
+= Stack // Pushes a single element on top of the stack.
+= StackProxy // Pushes a single element on top of the stack.
+= SynchronizedBuffer // Append a single element to this buffer.
+= SynchronizedMap // Add a key/value pair to this map.
+= SynchronizedMap // Add two or more key/value pairs to this map.
+= SynchronizedPriorityQueue // Inserts a single element into the priority queue.
+= SynchronizedQueue // Inserts a single element at the end of the queue.
+= SynchronizedSet // Add a new element to the set.
+= SynchronizedStack // Pushes a single element on top of the stack.
+= RichStringBuilder // Append a single element to this buffer.
+= Reactions // Add a reaction.
+= RefBuffer // Append a single element to this buffer.
+= CachedFileStorage // adds a node, setting this.dirty to true as a side effect
+= IndexedStorage // adds a node, setting this.dirty to true as a side effect
+= SetStorage // adds a node, setting this.dirty to true as a side effect
-> Map.MapTo
-> Map.MapTo
-- List // Computes the difference between this list and the given list ...
-- Map // Remove a sequence of keys from this map
-- Set // Remove all the elements provided by an iterator ...
-- SortedMap // Remove a sequence of keys from this map
-- MutableIterable // Operator shortcut for removeAll.
-- Set // Operator shortcut for removeAll.
-- Map // Remove a sequence of keys from this map
-- MapProxy // Remove a sequence of keys from this map
-- Set // Remove all the elements provided by an iterator ...
--= Map // Remove a sequence of keys from this map
--= MapProxy // Remove a sequence of keys from this map
--= Set // Remove all the elements provided by an iterator ...
--= SetProxy // Remove all the elements provided by an iterator ...
--= SynchronizedMap // Remove a sequence of keys from this map
--= SynchronizedSet // Remove all the elements provided by an iterator ...
- BigDecimal // Subtraction of BigDecimals
- BigInt // Subtraction of BigInts
- Byte
- Char
- Double
- Enumeration.SetXX // Remove a single element from a set.
- Float
- Int
- List // Computes the difference between this list and the given object ...
- Long
- Short
- EmptyMap // Remove a key from this map
- EmptySet // Remove a single element from a set.
- HashMap // Remove a key from this map
- HashSet // Remove a single element from a set.
- IntMap // Remove a key from this map
- ListMap.Node // Creates a new mapping without the given key. ...
- ListMap // This creates a new mapping without the given key. ...
- ListSet.Node // - can be used to remove a single element from ...
- ListSet // - can be used to remove a single element from ...
- LongMap // Remove a key from this map
- Map // Remove a key from this map
- Map // Remove two or more keys from this map
- Map1 // Remove a key from this map
- Map2 // Remove a key from this map
- Map3 // Remove a key from this map
- Map4 // Remove a key from this map
- Set // Remove a single element from a set.
- Set // Remove two or more elements from this set.
- Set1 // Remove a single element from a set.
- Set2 // Remove a single element from a set.
- Set3 // Remove a single element from a set.
- Set4 // Remove a single element from a set.
- SortedMap // Remove a key from this map
- SortedMap // Remove two or more keys from this map
- TreeHashMap // Remove a key from this map
- TreeMap // Remove a key from this map
- TreeSet // Remove a single element from a set.
- UnbalancedTreeMap.Node // Remove a key from this map
- UnbalancedTreeMap // Remove a key from this map
- Map // Remove a key from this map
- MutableIterable
- Set
- ListBuffer // Removes a single element from the buffer and return ...
- Map // Remove a key from this map
- Map // Remove two or more keys from this map
- MapProxy // Remove a key from this map
- MapProxy // Remove two or more keys from this map
- Set // Remove a new element from the set.
- Set // Remove two or more elements from this set.
-= Buffer // removes "a" from the collection.
-= Collection // removes "a" from the collection.
-= Map // Remove a key from this map, noop if key is not present.
-= BitSet // Clears the i-th bit.
-= Buffer // Removes a single element from this buffer, at its first occurrence. ...
-= HashMap // Remove a key from this map, noop if key is not present.
-= HashSet // Removes a single element from a set.
-= ImmutableMapAdaptor // Remove a key from this map, noop if key is not present.
-= ImmutableSetAdaptor // Removes a single element from a set.
-= JavaMapAdaptor // Remove a key from this map, noop if key is not present.
-= JavaSetAdaptor // Removes a single element from a set.
-= LinkedHashMap // Remove a key from this map, noop if key is not present.
-= LinkedHashSet // Removes a single element from a set.
-= ListBuffer // Remove a single element from this buffer. It takes linear time ...
-= Map // Remove a key from this map, noop if key is not present.
-= Map // Remove two or more keys from this map
-= MapProxy // Remove a key from this map, noop if key is not present.
-= MapProxy // Remove two or more keys from this map
-= ObservableMap // Remove a key from this map, noop if key is not present.
-= ObservableSet // Removes a single element from a set.
-= OpenHashMap // Remove a key from this map, noop if key is not present.
-= Set // Remove two or more elements from this set.
-= Set // Removes a single element from a set.
-= SetProxy // Removes a single element from a set.
-= SynchronizedMap // Remove a key from this map, noop if key is not present.
-= SynchronizedMap // Remove two or more keys from this map
-= SynchronizedSet // Removes a single element from a set.
-= Reactions // Remove the given reaction.
-= CachedFileStorage // removes a tree, setting this.dirty to true as a side effect
-= IndexedStorage // removes a tree, setting this.dirty to true as a side effect
/% BigInt // Returns a pair of two BigInts containing (this / that) and (this % that).
/: Iterable // Similar to foldLeft but can be used as ...
/: IterableProxy // Similar to foldLeft but can be used as ...
/: Iterator // Similar to foldLeft but can be used as ...
/ BigDecimal // Division of BigDecimals
/ BigInt // Division of BigInts
/ Byte
/ Char
/ Double
/ Float
/ Int
/ Long
/ Short
:/: Document
::: List
:: List
:: Document
:\ Iterable // An alias for foldRight. ...
:\ IterableProxy // An alias for foldRight. ...
:\ Iterator // An alias for foldRight. ...
== Any // o == arg0 is the same as o.equals(arg0).
== AnyRef // o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).
== Boolean
== Byte
== Char
== Double
== Float
== Int
== Long
== Short
? Actor // Receives the next message from this actor's mailbox.
? Channel // Receives the next message from this Channel.
? InputChannel // Receives the next message from this Channel.
? Parsers.Parser // Returns a parser that optionally parses what this parser parses.
? Parsers.Parser // Returns a parser that optionally parses what this parser parses.
\ NodeSeq // Projection function. Similar to XPath, use this \ "foo"
\\ NodeSeq // projection function. Similar to XPath, use this \\ 'foo
^ BigInt // Bitwise exclusive-or of BigInts
^ Boolean
^ Byte
^ Char
^ Int
^ Long
^ Short
^? Parsers.Parser // A parser combinator for partial function application
^? Parsers.Parser // A parser combinator for partial function application
^^ Parsers.Parser // A parser combinator for function application
^^ Parsers.Parser // A parser combinator for function application
^^ Parsers.UnitParser // A parser combinator for function application
^^^ Parsers.Parser
| BigInt // Bitwise or of BigInts
| Boolean
| Byte
| Char
| Enumeration.Set32 // Equivalent to ++ for bit sets. Returns a set ...
| Enumeration.Set32 // Equivalent to + for bit sets. Returns a set ...
| Enumeration.Set64 // Equivalent to ++ for bit sets. Returns a set ...
| Enumeration.Set64 // Equivalent to + for bit sets. Returns a set ...
| Enumeration.SetXX // Equivalent to ++ for bit sets. Returns a set ...
| Enumeration.SetXX // Equivalent to + for bit sets. Returns a set ...
| Int
| Long
| Short
| Parsers.Parser // A parser combinator for alternative composition
| Parsers.Parser // A parser combinator for alternative composition
| Parsers.UnitParser // A parser combinator for alternative composition
|| Boolean
||| Parsers.Parser
||| Parsers.Parser // A parser combinator for alternative with longest match composition
||| Parsers.Parser // A parser combinator for alternative with longest match composition
||| Parsers.UnitParser // A parser combinator for alternative with longest match composition
~! Parsers.Parser // A parser combinator for non-back-tracking sequential composition
~! Parsers.Parser // A parser combinator for non-back-tracking sequential composition with a unit-parser
~! Parsers.Parser // A parser combinator for non-back-tracking sequential composition
~! Parsers.UnitParser // A parser combinator for non-back-tracking sequential composition with a unit-parser
~! Parsers.UnitParser // A parser combinator for non-back-tracking sequential composition
~> Parsers.Parser // A parser combinator for sequential composition which keeps only the right result
~ BigInt // Returns the bitwise complement of this BigNum
~ Parsers.OnceParser // A parser combinator for sequential composition
~ Parsers.Parser // A parser combinator for sequential composition
~ Parsers
~ Parsers.OnceParser // A parser combinator for sequential composition with a unit-parser
~ Parsers.OnceParser // A parser combinator for sequential composition
~ Parsers.Parser // A parser combinator for sequential composition with a unit-parser
~ Parsers.Parser // A parser combinator for sequential composition
~ Parsers.UnitOnceParser // A parser combinator for sequential composition with a unit-parser
~ Parsers.UnitOnceParser // A parser combinator for sequential composition
~ Parsers.UnitParser // A parser combinator for sequential composition with a unit-parser
~ Parsers.UnitParser // A parser combinator for sequential composition
unary_! Boolean
unary_+ Byte
unary_+ Char
unary_+ Double
unary_+ Float
unary_+ Int
unary_+ Long
unary_+ Short
unary_- BigDecimal // Returns a BigDecimal whose value is the negation of this BigDecimal
unary_- BigInt // Returns a BigInt whose value is the negation of this BigInt
unary_- Byte
unary_- Char
unary_- Double
unary_- Float
unary_- Int
unary_- Long
unary_- Short
unary_~ Byte
unary_~ Char
unary_~ Int
unary_~ Long
unary_~ Short

Answer 11

这里有很好的详尽答案。

对我来说一个关键点是这些有 2 类

op 提到的符号是 scala sdk 中的函数名称。在 scala 中，编写具有这些字符（包括 unicode 字符）名称的函数是合法的。这将是一个很好的长列表，尝试提及其他答案中已经提到的 sdk 中的所有符号

然后，有些符号不是函数名称，而是语言语法本身的一部分，例如 =>< /code>、_ 或运算符，例如 &&、|| 等。