詞彙表

來自 Scala 權威書籍 Scala 程式設計 的詞彙表。

• 代數資料類型

  一種透過提供多種選擇來定義的類型，每個選擇都附有自己的建構函式。通常會搭配一種透過模式比對來分解類型的途徑。這個概念存在於規範語言和函式程式語言中。代數資料類型可以用案例類別在 Scala 中模擬。

• 選擇

  比對表達式的分支。其形式為「case 模式 => 表達式」。選擇的另一個名稱是案例。

• 註解

  註解出現在原始碼中，並附加到語法的某個部分。註解可以由電腦處理，因此您可以使用它們有效地為 Scala 新增一個擴充功能。

• 匿名類別

  匿名類別是由 Scala 編譯器從一個新的表達式產生的合成子類別，其中類別或特質名稱後接大括號。大括號包含匿名子類別的主體，主體可以是空的。但是，如果 new 之後的名稱是指包含抽象成員的特質或類別，則必須在大括號內定義匿名子類別的主體時將這些抽象成員具體化。

• 匿名函式

  函式文字 的另一個名稱。

• 套用

  你可以對參數套用方法、函數或封閉，表示你對這些參數呼叫它。

• 參數

  當函數被呼叫時，會為函數的每個參數傳遞一個參數。參數是參考參數的變數。參數是在呼叫時傳遞的物件。此外，應用程式可以接受 (命令列) 參數，這些參數會顯示在傳遞給單例物件的 main 方法的 Array[String] 中。

• 指定

  你可以將物件指定給變數。之後，變數會參考物件。

• 輔助建構函式

  在類別定義的大括弧內定義的額外建構函式，看起來像是名為 this 的方法定義，但沒有結果類型。

• 區塊

  一個或多個被大括弧包圍的表達式和宣告。當區塊評估時，其所有表達式和宣告都會依序處理，然後區塊會傳回最後一個表達式的值作為自己的值。區塊通常用作函數、for 表達式、while 迴圈和任何你想將多個陳述式分組在一起的地方的主體。更正式地說，區塊是一種封裝結構，你只能看到副作用和結果值。因此，你用來定義類別或物件的大括弧不會形成區塊，因為從外部可以看到欄位和方法 (定義在這些大括弧內)。此類大括弧會形成範本。

• 繫結變數

  表達式的繫結變數是在表達式內同時使用和定義的變數。例如，在函數文字表達式 (x: Int) => (x, y) 中，變數 x 和 y 都會使用，但只有 x 會繫結，因為它在表達式中定義為 Int，並且是表達式所描述函數的唯一參數。

• 依名稱傳遞參數

  一個在參數類型前面標記有 => 的參數，例如 (x: => Int)。對應於依名稱傳遞參數的參數，是在方法被呼叫之前評估，而不是在方法內部每次參數被名稱參照時評估。如果一個參數不是依名稱傳遞，它就是依值傳遞。

• 依值傳遞參數

  一個在參數類型前面沒有標記 => 的參數，例如 (x: Int)。對應於依值傳遞參數的參數，是在方法被呼叫之前評估。依值傳遞參數與依名稱傳遞參數相反。

• 類別

  使用 class 關鍵字定義，一個類別可以是抽象或具體的，並且在實例化時可以用類型和值參數化。在 new Array[String](2) 中，正在實例化的類別是 Array，而結果值類型是 Array[String]。一個採用類型參數的類別稱為類型建構函數。類型也可以有類別，如下所示：類型 Array[String] 的類別是 Array。

• 閉包

  一個函式物件，它擷取自由變數，並且在建立時對當時可見的變數「封閉」。

• 伴隨類別

  一個與在同一個來源檔案中定義的單例物件同名的類別。類別是單例物件的伴隨類別。

• 伴隨物件

  一個與在同一個來源檔案中定義的類別同名的單例物件。伴隨物件和類別可以存取彼此的私有成員。此外，在伴隨物件中定義的任何隱式轉換，都可以在類別被使用的任何地方使用。

• 反變

  一個反變註解可以透過在類型參數前面加上減號 (-) 來套用於類別或特質的類型參數。然後，類別或特質與註解類型參數以反變的方式進行子類型化，與類型註解參數相反。例如，Function1 在其第一個類型參數中是反變的，因此 Function1[Any, Any] 是 Function1[String, Any] 的子類型。

• 協變

  協變註解可以套用在類別或特質的型別參數上，方法是在型別參數前加上正號 (+)。然後類別或特質會以協變的方式子類型化，也就是與註解型別參數同方向。例如，List 在其型別參數中是協變的，因此 List[String] 是 List[Any] 的子類型。

• 柯里化

  一種撰寫具有多個參數清單函式的寫法。例如 def f(x: Int)(y: Int) 是一個具有兩個參數清單的柯里化函式。柯里化函式是透過傳遞多個引數清單來套用，例如：f(3)(4)。然而，也可以撰寫柯里化函式的部分套用，例如 f(3)。

• 宣告

  你可以宣告抽象欄位、方法或型別，這會給予實體一個名稱，但沒有實作。宣告和定義之間的主要差異在於定義會為已命名的實體建立實作，而宣告則不會。

• 定義

  在 Scala 程式中定義某個東西是指給予它一個名稱和實作。你可以定義類別、特質、單例物件、欄位、方法、區域函式、區域變數等等。由於定義總是包含某種實作，因此抽象成員是宣告的，而不是定義的。

• 直接子類別

  一個類別是其直接父類別的直接子類別。

• 直接父類別

  類別或特質直接衍生的類別，在繼承階層中位於其上方的最近類別。如果類別 Parent 在類別 Child 的選用 extends 子句中被提及，則 Parent 是 Child 的直接超類別。如果特質在 Child 的 extends 子句中被提及，則該特質的直接超類別是 Child 的直接超類別。如果 Child 沒有 extends 子句，則 AnyRef 是 Child 的直接超類別。如果類別的直接超類別採用類型參數，例如類別 Child extends Parent[String]，則 Child 的直接超類別仍然是 Parent，而不是 Parent[String]。另一方面，Parent[String] 會是 Child 的直接超類型。請參閱 超類型 以進一步了解類別和類型之間的區別。

• 相等性

  在沒有限定詞的情況下使用時，相等性 是由 == 表示的值之間的關係。另請參閱 參考相等性。

• 存在類型

  存在類型包含對未知類型變數的參考。例如，Array[T] forSome { type T } 是存在類型。它是 T 的陣列，其中 T 是某個完全未知的類型。對 T 的所有假設都是它確實存在。這個假設很薄弱，但至少表示 Array[T] forSome { type T } 確實是陣列，而不是香蕉。

• 表達式

  任何產生結果的 Scala 程式碼。您也可以說表達式評估為結果或產生值。

• 篩選器

  在 for 表達式 中，一個 if 後面接著一個布林表達式。在 for(i <- 1 to 10; if i % 2 == 0) 中，篩選器為「if i % 2 == 0」。if 右邊的值是 篩選器表達式。也稱為防護裝置。

• 篩選器表達式

  篩選器表達式 是在 for 表達式 中 if 後面的布林表達式。在 for( i <- 1 to 10 ; if i % 2 == 0) 中，篩選器表達式為「i % 2 == 0」。

• 一級函數

  Scala 支援一級函數，表示您可以使用函數文字語法表示函數，例如 (x: Int) => x + 1，而且函數可以用物件表示，稱為 函數值。

• for 推論

  for 推論 是一種 for 表達式，會建立新的集合。對於 for 推論的每次反覆運算，yield 子句會定義新集合的元素。例如，for (i <- (0 until 2); j <- (2 until 4)) yield (i, j) 會傳回集合 Vector((0,2), (0,3), (1,2), (1,3))。

• for 表達式

  for 表達式 可能是 for 迴圈（會反覆運算一個或多個集合），或 for 推論（會從一個或多個集合的元素建立新的集合）。for 表達式是由 產生器、篩選器、變數定義和（在 for 推論 的情況下）yield 子句組成。

• for 迴圈

  for 迴圈 是一種 for 表達式，會迴圈一個或多個集合。由於 for 迴圈會傳回單位，因此通常會產生副作用。例如，for (i <- 0 until 100) println(i) 會列印數字 0 到 99。

• 自由變數

  表達式的自由變數是在表達式中使用但未在表達式中定義的變數。例如，在函數文字表達式 (x: Int) => (x, y) 中，兩個變數 x 和 y 都被使用，但只有 y 是自由變數，因為它未在表達式中定義。

• 函數

  函數可以使用引數清單呼叫，以產生結果。函數具有參數清單、主體和結果類型。類別、特質或單例物件的成員函數稱為方法。在其他函數中定義的函數稱為局部函數。結果類型為 Unit 的函數稱為程序。原始碼中的匿名函數稱為函數文字。在執行階段，函數文字會實例化為稱為函數值的物件。

• 函數文字

  Scala 原始碼中沒有名稱的函數，使用函數文字語法指定。例如，(x: Int, y: Int) => x + y。

• 函數值

  可以像其他任何函數一樣呼叫的函數物件。函數值的類別會延伸 scala 套件中的 FunctionN 特質之一（例如，Function0、Function1），通常在原始碼中透過函數文字語法表示。當呼叫函數值的 apply 方法時，函數值會「呼叫」。擷取自由變數的函數值是閉包。

• 函數式風格

  函數式風格的程式設計強調函數和評估結果，並弱化運算發生的順序。此風格的特徵是將函數值傳遞到迴圈方法、不可變資料、沒有副作用的方法。這是 Haskell 和 Erlang 等語言的主要範例，與命令式風格形成對比。

• 產生器

  一個 產生器 定義一個命名值，並在 for 表達式 中指派給它一系列的值。例如，在 for(i <- 1 to 10) 中，產生器是「i <- 1 to 10」。<- 右邊的值是 產生器表達式。

• 產生器表達式

  一個 產生器表達式 在 for 表達式 中產生一系列的值。例如，在 for(i <- 1 to 10) 中，產生器表達式是「1 to 10」。

• 泛型類別

  一個採用類型參數的類別。例如，因為 scala.List 採用類型參數，scala.List 是個 泛型類別。

• 泛型特質

  一個採用類型參數的特質。例如，因為特質 scala.collection.Set 採用類型參數，所以它是一個 泛型特質。

• 守衛

  請參閱 filter。

• 輔助函式

  一個函式的目的是為附近一個或多個其他函式提供服務。輔助函式通常實作為局部函式。

• 輔助方法

  一個 輔助函式，是類別的成員。輔助方法通常是私有的。

• 不可變

  如果一個物件的值在建立後無法以任何對用戶端可見的方式變更，則該物件是 不可變的。物件可能可變或不可變。

• 命令式風格

  命令式風格 的程式設計強調小心安排運算的順序，以便它們的效果以正確的順序發生。此風格的特徵是使用迴圈進行反覆運算、就地變異資料，以及具有副作用的方法。它是 C、C++、C# 和 Java 等語言的主要範例，與 函式式風格 相反。

• 初始化

  當在 Scala 原始碼中定義變數時，你必須使用一個物件來 初始化 它。

• 實例

  一個 實例 或類別實例是一個物件，一個僅在執行時存在的概念。

• 實例化

  實例化一個類別是從類別中建立一個新物件，這個動作只會在執行時期發生。

• 不變式

  不變式有兩種用法。它可以表示當資料結構良好形成時，永遠為真的屬性。例如，已排序的二元樹的不變式是每個節點都比其右子節點小（如果它有右子節點）。不變式有時也用作非變異的同義詞：「類別 Array 在其型別參數中是不變的。」

• 呼叫

  你可以呼叫一個方法、函式或閉包於參數上，這表示它的主體將會使用指定的參數執行。

• JVM

  JVM 是 Java 虛擬機器，或 執行時期，它會主機一個正在執行的 Scala 程式。

• 文字

  1、"One" 和 (x: Int) => x + 1 是文字的範例。文字是一種描述物件的簡寫方式，其中簡寫會完全反映已建立物件的結構。

• 區域函式

  區域函式是在區塊中定義的 def。相對地，定義為類別、特質或單例物件成員的 def 稱為 方法。

• 區域變數

  區域變數是在區塊中定義的 val 或 var。雖然類似於 區域變數，函式的參數不會稱為區域變數，而只稱為參數或「變數」，沒有「區域」這個字。

• 成員

  成員是類別、特質或單例物件範本中任何已命名的元素。成員可以使用其擁有者的名稱、一個點和其簡單名稱來存取。例如，在類別中定義的頂層欄位和方法是該類別的成員。在類別中定義的特質是其封閉類別的成員。在類別中使用 type 關鍵字定義的型別是該類別的成員。類別是其定義所在的套件的成員。相對地，區域變數或區域函式不是其周圍區塊的成員。

• 訊息

  Actor 透過傳送訊息彼此溝通。傳送訊息不會中斷接收者正在執行的動作。接收者可以等到它完成目前的活動且其不變式已重新建立。

• 元程式設計

  元程式設計軟體是其輸入本身就是軟體的軟體。編譯器是元程式，例如 scaladoc 等工具。要使用註解，就需要元程式設計軟體。

• 方法

  方法是某些類別、特質或單例物件的成員函式。

• 混入

  在混入組合中使用特質時，特質稱為混入。換句話說，在「trait Hat」中，Hat 只是特質，但在「new Cat extends AnyRef with Hat」中，Hat 可以稱為混入。用作動詞時，「混入」是兩個字。例如，您可以將特質混入類別或其他特質中。

• 混入組合

  將特質混入類別或其他特質的過程。混入組合與傳統的多重繼承不同，在於定義特質時不知道超級參考的類型，而是每次將特質混入類別或其他特質時才重新決定。

• 修飾詞

  以某種方式限定類別、特質、欄位或方法定義的關鍵字。例如，private 修飾詞表示正在定義的類別、特質、欄位或方法是私有的。

• 多重定義

  如果您使用 val v1, v2, v3 = exp 語法，可以將同一個表達式指定給多重定義。

• 非變異

  預設情況下，類別或特質的類型參數為非變異。因此，當該參數變更時，類別或特質不會成為子類型。例如，由於類別 Array 在其類型參數中為非變異，因此 Array[String] 既不是 Array[Any] 的子類型，也不是其超類型。

• 運算

  在 Scala 中，每個運算都是方法呼叫。方法可以在運算符表示法中呼叫，例如 b + 2，而在該表示法中，+ 是運算符。

• 參數

  函式可以接受 0 到多個參數。每個參數都有名稱和類型。參數和引數之間的區別在於，引數是指呼叫函式時傳遞的實際物件。參數是參考那些傳遞引數的變數。

• 無參數函數

  未定義任何空括號的函數，此函數不接受任何參數。呼叫無參數函數時不能提供括號。這支援統一存取原則，讓def能變更為val，而無須變更用戶端程式碼。

• 無參數方法

  無參數方法是無參數函數，也是類別、特質或單例物件的成員。

• 參數化欄位

  定義為類別參數的欄位。

• 部分套用函數

  在表達式中使用的函數，但缺少部分參數。例如，如果函數f的型別為Int => Int => Int，則f和f(1)為部分套用函數。

• 路徑依賴型別

  如swiss.cow.Food的型別。swiss.cow部分為路徑，用於形成對物件的參考。型別的意義會根據您用來存取的的路徑而有所不同。例如，swiss.cow.Food和fish.Food型別是不同的型別。

• 模式

  在match表達式選項中，模式會出現在每個case關鍵字後面，並在模式防護或=>符號之前。

• 模式防護

  在match表達式選項中，模式防護會出現在模式之後。例如，在「case x if x % 2 == 0 => x + 1」中，模式防護為「if x % 2 == 0」。只有在模式相符且模式防護產生 true 時，才會選取有模式防護的案例。

• 謂詞

  謂詞是結果型別為Boolean的函數。

• 主要建構函式

  類別的主要建構函式，會呼叫超類別建構函式（如有需要）、將欄位初始化為傳遞的值，並執行在類別大括號中定義的任何頂層程式碼。欄位僅會初始化為未傳遞至超類別建構函式的值參數，但未用於類別主體的欄位除外，且可以最佳化移除。

• 程序

  程序是結果類型為 Unit 的函數，因此僅為其副作用執行。

• 可重新指派

  變數可能可重新指派或不可重新指派。var 可重新指派，而 val 則不可重新指派。

• 遞迴

  如果函數呼叫自己，則該函數為遞迴。如果函數呼叫自己的唯一位置是函數的最後一個表達式，則該函數為 尾遞迴。

• 參考

  參考是指標的 Java 抽象，它唯一識別駐留在 JVM 堆積的物件。參考類型變數持有對物件的參考，因為參考類型（AnyRef 的實例）實作為駐留在 JVM 堆積的 Java 物件。相較之下，值類型變數有時可能持有參考（對包裝器類型），有時則可能不持有（當物件表示為原始值時）。一般來說，Scala 變數 參考 物件。術語「參考」比「持有參考」更抽象。如果類型為 scala.Int 的變數目前表示為原始 Java int 值，則該變數仍參考 Int 物件，但未涉及任何參考。

• 參考相等

  參考相等表示兩個參考識別同一個 Java 物件。僅對於參考類型，才能透過在 AnyRef 中呼叫 eq 來確定參考相等。（在 Java 程式中，可以使用 == 在 Java 參考類型 上確定參考相等。）

• 參考類型

  參考類型是 AnyRef 的子類別。參考類型的實例在執行階段總是駐留在 JVM 的堆積上。

• 參考透明性

  獨立於時間背景且沒有副作用的函數的屬性。對於特定輸入，可以將參考透明函數的呼叫替換為其結果，而不會變更程式語意。

• 參考

  執行中的 Scala 程式中的變數總是參照某些物件。即使該變數指定給 null，它在概念上仍參照 Null 物件。在執行階段，物件可以由 Java 物件或原始類型的值實作，但 Scala 讓程式設計師在想像程式執行時，以更抽象的層級思考他們的程式碼。另請參閱 參考。

• 精緻類型

  一種透過在花括號內提供基本類型和多個成員而形成的類型。花括號中的成員精緻化基本類型中存在的類型。例如，「吃草的動物」的類型是 Animal { type SuitableFood = Grass }。

• 結果

  Scala 程式中的表達式會產生結果。Scala 中每個表達式的結果都是一個物件。

• 結果類型

  方法的結果類型是呼叫方法所產生的值的類型。（在 Java 中，這個概念稱為傳回類型。）

• 傳回

  Scala 程式中的函式傳回一個值。您可以將這個值稱為函式的 結果。您也可以說函式產生這個值。Scala 中每個函式的結果都是一個物件。

• 執行階段

  主控執行中的 Scala 程式的 Java 虛擬機器，或 JVM。執行階段涵蓋 Java 虛擬機器規格所定義的虛擬機器，以及 Java API 和標準 Scala API 的執行階段函式庫。執行階段（run 和 time 之間有空格）這個片語表示程式正在執行時，與編譯階段形成對比。

• 執行階段類型

  物件在執行階段的類型。相對而言，靜態類型是在編譯階段表達式的類型。大多數執行階段類型只是沒有類型參數的裸類別。例如，"Hi" 的執行階段類型是 String，而 (x: Int) => x + 1 的執行階段類型是 Function1。執行階段類型可以用 isInstanceOf 進行測試。

• 指令碼

  包含頂層定義和陳述式的檔案，可以用 scala 直接執行，而不用明確編譯。指令碼必須以表達式結尾，而不是定義。

• 選擇器

  在 match 表達式中進行比對的值。例如，在「s match { case _ => }」中，選擇器是 s。

• 自我類型

  特質的自我類型是特質內部使用的假設類型 this，接收器。任何混入特質的具體類別都必須確保其類型符合特質的自我類型。自我類型最常見的用途是將大型類別分成數個特質（如 Programming in Scala 的第 29 章所述）。

• 半結構化資料

  XML 資料是半結構化的。它比平面二進位檔或文字檔更結構化，但它沒有程式語言資料結構的完整結構。

• 序列化

  您可以將物件序列化成位元組串流，然後將其儲存到檔案中或透過網路傳輸。您稍後可以在不同的電腦上反序列化位元組串流，並取得與原始序列化物件相同的物件。

• 遮蔽

  新的區域變數宣告會遮蔽封閉範圍中同名的變數。

• 簽章

  簽章是 類型簽章 的簡稱。

• 單例物件

  使用 object 關鍵字定義的物件。每個單例物件只有一個實例。與類別同名的單例物件，且定義在與該類別相同的原始檔中，就是該類別的 伴隨物件。該類別就是它的 伴隨類別。沒有伴隨類別的單例物件就是 獨立物件。

• 獨立物件

  沒有 伴隨類別 的 單例物件。

• 陳述

  表達式、定義或匯入，即，可以在 Scala 原始碼中放入範本或區塊的內容。

• 靜態類型

  請參閱 類型。

• 結構類型

  精煉部分不在基本類型中的 精煉類型。例如，{ def close(): Unit } 是結構類型，因為基本類型是 AnyRef，而 AnyRef 沒有名為 close 的成員。

• 子類別

  類別是其所有 超類別 和 超特質 的子類別。

• 子特質

  特質是其所有 超特質 的子特質。

• 子類型

  Scala 編譯器允許任何類型的子類型用於需要該類型的任何地方。對於不採用任何類型參數的類別和特質，子類型關係反映子類別關係。例如，如果類別 Cat 是抽象類別 Animal 的子類別，且兩者都不採用類型參數，則類型 Cat 是類型 Animal 的子類型。同樣地，如果特質 Apple 是特質 Fruit 的子特質，且兩者都不採用類型參數，則類型 Apple 是類型 Fruit 的子類型。然而，對於採用類型參數的類別和特質，變異性會發揮作用。例如，由於抽象類別 List 被宣告為在其單一類型參數中協變（即 List 被宣告為 List[+A]），因此 List[Cat] 是 List[Animal] 的子類型，而 List[Apple] 是 List[Fruit] 的子類型。即使這些類型的每個類別都是 List，這些子類型關係仍然存在。相比之下，由於 Set 未被宣告為在其類型參數中協變（即 Set 被宣告為 Set[A]，沒有加號），因此 Set[Cat] 不是 Set[Animal] 的子類型。子類型應正確實作其超類型的合約，以便套用 Liskov 替換原則，但編譯器僅在類型檢查層級驗證此屬性。

• 超類別

  類別的超類別包括其直接超類別、其直接超類別的直接超類別，依此類推，一直到 Any。

• 超特質

  類別或特質的超級特質（若有）包含所有直接混入類別或特質或任何其超類別的特質，加上這些特質的任何超級特質。

• 超類別

  類別是其所有子類別的超類別。

• 合成類別

  合成類別是由編譯器自動產生，而非由程式設計師手寫。

• 尾遞迴

  函式為尾遞迴，如果函式呼叫自己的唯一位置是函式的最後一個運算。

• 目標型別

  目標型別是考量預期型別的型別推論形式。例如，在 nums.filter((x) => x > 0) 中，Scala 編譯器推論 x 的型別為 nums 的元素型別，因為 filter 方法會對 nums 的每個元素呼叫函式。

• 範本

  範本是類別、特質或單例物件定義的主體。它定義類別、特質或物件的型別簽章、行為和初始狀態。

• 特質

  特質（使用 trait 關鍵字定義）類似於無法接受任何值參數且可透過稱為 mixin 組合 的程序「混入」類別或其他特質的抽象類別。當特質混入類別或特質時，稱為 mixin。特質可以參數化一個或多個型別。當參數化型別時，特質會建構一個型別。例如，Set 是接受單一型別參數的特質，而 Set[Int] 是型別。此外，Set 稱為型別 Set[Int] 的「特質」。

• 型別

  Scala 程式中的每個變數和表達式都有在編譯時已知的型別。型別限制變數在執行時可以參照或表達式可以產生的可能值。變數或表達式的型別也可以稱為靜態型別（如果需要與物件的 執行時期型別 區分）。換句話說，「型別」本身表示靜態型別。型別與類別不同，因為接受型別參數的類別可以建構許多型別。例如，List 是類別，但不是型別。 List[T] 是具有自由型別參數的型別。 List[Int] 和 List[String] 也是型別（稱為基本型別，因為它們沒有自由型別參數）。型別可以有「類別」或「特質」。例如，型別 List[Int] 的類別是 List。型別 Set[String] 的特質是 Set。

• 類型約束

  有些 註解 是類型約束，表示它們會新增額外的限制或約束，針對類型包含哪些值。例如，@positive 可能是類型 Int 的類型約束，將 32 位元整數的類型限制為正整數。類型約束不會由標準 Scala 編譯器檢查，但必須由額外的工具或編譯器外掛程式檢查。

• 類型建構函數

  採用類型參數的類別或特質。

• 類型參數

  泛型類別或泛型方法的參數，必須由類型填入。例如，類別 List 定義為「class List[T] { . . . 」，而方法 identity，是物件 Predef 的成員，定義為「def identity[T](x:T) = x」。這兩個範例中的 T 都是類型參數。

• 類型簽章

  方法的類型簽章包含其名稱、數量、順序和參數類型（如果有），以及其結果類型。類別、特質或單例物件的類型簽章包含其名稱、所有成員和建構函數的類型簽章，以及其宣告的繼承和混合關係。

• 統一存取原則

  統一存取原則指出，變數和無參數函數應使用相同的語法存取。Scala 支援此原則，方法是不允許在無參數函數的呼叫位置放置括號。因此，可以將無參數函數定義變更為 val，或反之亦然，而不會影響用戶端程式碼。

• 無法到達

  在 Scala 層級，物件可能會變成無法到達，在這個時候，執行階段可能會回收它們佔用的記憶體。無法到達並不一定表示沒有參照。參照類型（AnyRef 的實例）實作為存在於 JVM 堆疊中的物件。當參照類型的實例變成無法到達時，它確實變成沒有參照，而且可以進行垃圾回收。值類型（AnyVal 的實例）實作為原始類型值和 Java 包裝類型（例如 java.lang.Integer）的實例，存在於堆疊中。值類型實例可以在參照它們的變數生命週期中進行封裝（從原始值轉換成包裝物件）和解封裝（從包裝物件轉換成原始值）。如果目前表示為 JVM 堆疊上包裝物件的值類型實例變成無法到達，它確實變成沒有參照，而且可以進行垃圾回收。但是，如果目前表示為原始值的值類型變成無法到達，那麼它不會變成沒有參照，因為在那個時間點它不存在於 JVM 堆疊上的物件中。執行階段可能會回收無法到達物件佔用的記憶體，但是，如果 Int 例如在執行階段由原始 Java int 實作，而原始 Java int 佔用執行方法的堆疊框架中的一些記憶體，那麼當方法完成時堆疊框架彈出時，那個物件的記憶體就會被「回收」。參照類型的記憶體，例如 Strings，在它們變成無法到達後可能會被 JVM 的垃圾回收器回收。

• 沒有參照

  請參閱 無法到達。

• 值

  Scala 中任何運算或表達式的結果都是值，而且在 Scala 中，每個值都是物件。值這個術語基本上表示記憶體中物件的映像（在 JVM 的堆疊或堆疊中）。

• 值類型

  值類型是 AnyVal 的任何子類別，例如 Int、Double 或 Unit。這個術語在 Scala 原始碼層級有意義。在執行階段，對應於 Java 原始類型的值類型實例可能會實作為原始類型值或包裝類型實例，例如 java.lang.Integer。在值類型實例的生命週期中，執行階段可能會在原始類型和包裝類型之間來回轉換它（即，封裝和解封裝它）。

• 變數

  指稱物件的名稱實體。變數可以是 val 或 var。定義時，val 和 var 都必須初始化，但只有 var 可以稍後重新指派，以指稱不同的物件。

• 變異性

  類別或特質的型別參數可以用變異性註解標記，可以是 共變 (+) 或 反變 (-)。此類變異性註解指出共用類別或特質的子型別運作方式。例如，共用類別 List 在其型別參數中是共變的，因此 List[String] 是 List[Any] 的子型別。預設情況下，即，沒有 + 或 - 註解，型別參數是 不變 的。

• 產生

  表達式可以產生結果。yield 關鍵字指定 for 理解 的結果。