Term updates.

Author: ShikiSuen

Sources/Megrez/0_Megrez.swift

@@ -8,12 +8,12 @@ public enum Megrez {}
 // 天權星引擎（Megrez Compositor）特色：
 // - 原生 Swift 實作，擁有完備的 Swift 5.3 ~ 5.9 支援、也可以用作任何 Swift 6 專案的相依套件（需使用者自行處理對跨執行緒安全性的需求）。
 // - API 以陣列的形式處理輸入的 key。而且，在獲取候選字詞內容的時候，也可以徹底篩除橫跨游標的詞。
-// - 爬軌算法（Walking Algorithm）採用 Dijkstra 的算法，且經過效能最佳化處理、擁有比 DAG-Relax 算法更優的效能。
+// - 組句算法（Assembling Algorithm）採用 Dijkstra 的算法，且經過效能最佳化處理、擁有比 DAG-Relax 算法更優的效能。
 
 // 術語：
 
 // Grid: 節軌
-// Walk: 爬軌
+// Assemble: 組句
 // Node: 節點
-// SpanLength: 節幅
-// Span: 幅位
+// SegLength: 節幅
+// Segment: 幅節

Sources/Megrez/1_Compositor.swift

@@ -3,18 +3,18 @@
 // This code is released under the SPDX-License-Identifier: `LGPL-3.0-or-later`.
 
 extension Megrez.Compositor {
-  /// 爬軌函式，會以 Dijkstra 算法更新當前組字器的 walkedNodes。
+  /// 組句函式，會以 Dijkstra 算法更新當前組字器的 assembledNodes。
   ///
   /// 該算法會在圖中尋找具有最高分數的路徑，即最可能的字詞組合。
   ///
   /// 該算法所依賴的 HybridPriorityQueue 針對 Sandy Bridge 經過最佳化處理，
   /// 使得該算法在 Sandy Bridge CPU 的電腦上比 DAG 算法擁有更優的效能。
   ///
-  /// - Returns: 爬軌結果（已選字詞陣列）。
+  /// - Returns: 組句結果（已選字詞陣列）。
   @discardableResult
-  public func walk() -> [Megrez.Node] {
-    walkedNodes.removeAll()
-    guard !spans.isEmpty else { return [] }
+  public func assemble() -> [Megrez.Node] {
+    assembledNodes.removeAll()
+    guard !segments.isEmpty else { return [] }
 
     // 初期化資料結構。
     var openSet = HybridPriorityQueue<PrioritizedState>(reversed: true)
@@ -54,7 +54,7 @@ extension Megrez.Compositor {
       }
 
       // 處理下一個可能的節點。
-      for (length, nextNode) in spans[current.position] {
+      for (length, nextNode) in segments[current.position] {
         let nextPos = current.position + length
 
         // 計算新的權重分數。
@@ -102,7 +102,7 @@ extension Megrez.Compositor {
       current = state.prev
       // 備註：此處不需要手動 ASAN，因為沒有參據循環（Retain Cycle）。
     }
-    walkedNodes = pathNodes.map(\.copy)
+    assembledNodes = pathNodes.map(\.copy)
 
     // 手動 ASAN：批次清理所有 SearchState 物件以防止記憶體洩漏
     // 包括 visited set 中的所有狀態、openSet 中剩餘的狀態，以及 leadingState
@@ -111,7 +111,7 @@ extension Megrez.Compositor {
       openSet: &openSet,
       leadingState: start
     )
-    return walkedNodes
+    return assembledNodes
   }
 
   /// 部分清理已訪問狀態集合以控制記憶體使用

Sources/Megrez/2_Walker.swift Sources/Megrez/2_Assembler.swiftSources/Megrez/2_Walker.swift renamed to Sources/Megrez/2_Assembler.swift

@@ -120,7 +120,7 @@ extension Megrez.Compositor {
   /// - endAt 僅獲取在當前游標位置結束的節點內的候選字。
   public enum CandidateFetchFilter { case all, beginAt, endAt }
 
-  /// 返回在當前位置的所有候選字詞（以詞音配對的形式）。如果組字器內有幅位、且游標
+  /// 返回在當前位置的所有候選字詞（以詞音配對的形式）。如果組字器內有幅節、且游標
   /// 位於組字器的（文字輸入順序的）最前方（也就是游標位置的數值是最大合規數值）的
   /// 話，那麼這裡會對 location 的位置自動減去 1、以免去在呼叫該函式後再處理的麻煩。
   /// - Parameter location: 游標位置，必須是顯示的游標位置、不得做任何事先糾偏處理。
@@ -151,8 +151,8 @@ extension Megrez.Compositor {
           guard theAnchor.location == location else { return }
         case .endAt:
           guard theNode.keyArray.last == keyAtCursor else { return }
-          switch theNode.spanLength {
-          case 2... where theAnchor.location + theAnchor.node.spanLength - 1 != location: return
+          switch theNode.segLength {
+          case 2... where theAnchor.location + theAnchor.node.segLength - 1 != location: return
           default: break
           }
         }
@@ -232,10 +232,10 @@ extension Megrez.Compositor {
 
     guard let overridden = overridden else { return false } // 啥也不覆寫。
 
-    (overridden.location ..< min(spans.count, overridden.location + overridden.node.spanLength))
+    (overridden.location ..< min(segments.count, overridden.location + overridden.node.segLength))
       .forEach { i in
-        /// 咱們還得弱化所有在相同的幅位座標的節點的複寫權重。舉例說之前爬軌的結果是「A BC」
-        /// 且 A 與 BC 都是被覆寫的結果，然後使用者現在在與 A 相同的幅位座標位置
+        /// 咱們還得弱化所有在相同的幅節座標的節點的複寫權重。舉例說之前組句的結果是「A BC」
+        /// 且 A 與 BC 都是被覆寫的結果，然後使用者現在在與 A 相同的幅節座標位置
         /// 選了「DEF」，那麼 BC 的覆寫狀態就有必要重設（但 A 不用重設）。
         arrOverlappedNodes = fetchOverlappingNodes(at: i)
         arrOverlappedNodes.forEach { anchor in

Sources/Megrez/3_KeyValuePaired.swift

@@ -2,32 +2,32 @@
 // ====================
 // This code is released under the SPDX-License-Identifier: `LGPL-3.0-or-later`.
 
-// MARK: - Megrez.SpanUnit
+// MARK: - Megrez.Segment
 
 extension Megrez {
-  /// 幅位乃指一組共享起點的節點。其實是個辭典：[幅位長度: 節點]。
-  public typealias SpanUnit = [Int: Node]
+  /// 幅節乃指一組共享起點的節點。其實是個辭典：[幅節長度: 節點]。
+  public typealias Segment = [Int: Node]
 }
 
-extension Megrez.SpanUnit {
-  /// 幅位乃指一組共享起點的節點。其實是個辭典：[幅位長度: 節點]。
+extension Megrez.Segment {
+  /// 幅節乃指一組共享起點的節點。其實是個辭典：[幅節長度: 節點]。
   /// - Remark: 因為 Node 不是 Struct，所以會在 Compositor 被拷貝的時候無法被真實複製。
   /// 這樣一來，Compositor 複製品當中的 Node 的變化會被反應到原先的 Compositor 身上。
   /// 這在某些情況下會造成意料之外的混亂情況，所以需要引入一個拷貝用的建構子。
-  public init(SpanUnit target: Megrez.SpanUnit) {
+  public init(Segment target: Megrez.Segment) {
     self.init()
     target.forEach { theKey, theValue in
       self[theKey] = theValue.copy
     }
   }
 
-  /// 該幅位的硬拷貝。
-  public var hardCopy: Megrez.SpanUnit { .init(SpanUnit: self) }
+  /// 該幅節的硬拷貝。
+  public var hardCopy: Megrez.Segment { .init(Segment: self) }
 
   // MARK: - Dynamic Variables
 
-  /// 該幅位單元內的所有節點當中持有最長幅位的節點長度。
-  /// 該變數受該幅位的自身操作函式而被動更新。
+  /// 該幅節單元內的所有節點當中持有最長幅節的節點長度。
+  /// 該變數受該幅節的自身操作函式而被動更新。
   public var maxLength: Int { keys.max() ?? 0 }
 }
 
@@ -40,22 +40,22 @@ extension Megrez.Compositor {
   public func fetchOverlappingNodes(at givenLocation: Int) -> [(location: Int, node: Megrez.Node)] {
     var results = [(location: Int, node: Megrez.Node)]()
     let givenLocation = max(0, min(givenLocation, keys.count - 1))
-    guard spans.indices.contains(givenLocation) else { return results }
+    guard segments.indices.contains(givenLocation) else { return results }
 
     // 先獲取該位置的所有單字節點。
-    spans[givenLocation].keys.sorted().forEach { theSpanLength in
-      guard let node = spans[givenLocation][theSpanLength] else { return }
-      Self.insertAnchor(spanIndex: givenLocation, node: node, to: &results)
+    segments[givenLocation].keys.sorted().forEach { theSegLength in
+      guard let node = segments[givenLocation][theSegLength] else { return }
+      Self.insertAnchor(segmentIndex: givenLocation, node: node, to: &results)
     }
 
     // 再獲取以當前位置結尾或開頭的節點。
-    let begin: Int = givenLocation - min(givenLocation, maxSpanLength - 1)
+    let begin: Int = givenLocation - min(givenLocation, maxSegLength - 1)
     (begin ..< givenLocation).forEach { theLocation in
-      let (A, B): (Int, Int) = (givenLocation - theLocation + 1, spans[theLocation].maxLength)
+      let (A, B): (Int, Int) = (givenLocation - theLocation + 1, segments[theLocation].maxLength)
       guard A <= B else { return }
       (A ... B).forEach { theLength in
-        guard let node = spans[theLocation][theLength] else { return }
-        Self.insertAnchor(spanIndex: theLocation, node: node, to: &results)
+        guard let node = segments[theLocation][theLength] else { return }
+        Self.insertAnchor(segmentIndex: theLocation, node: node, to: &results)
       }
     }
 
@@ -64,14 +64,14 @@ extension Megrez.Compositor {
 
   /// 要在 fetchOverlappingNodes() 內使用的一個工具函式。
   private static func insertAnchor(
-    spanIndex location: Int, node: Megrez.Node,
+    segmentIndex location: Int, node: Megrez.Node,
     to targetContainer: inout [(location: Int, node: Megrez.Node)]
   ) {
     guard !node.keyArray.joined().isEmpty else { return }
     let anchor = (location: location, node: node)
     for i in 0 ... targetContainer.count {
       guard !targetContainer.isEmpty else { break }
-      guard targetContainer[i].node.spanLength <= anchor.node.spanLength else { continue }
+      guard targetContainer[i].node.segLength <= anchor.node.segLength else { continue }
       targetContainer.insert(anchor, at: i)
       return
     }

Sources/Megrez/4_SpanUnit.swift Sources/Megrez/4_Segment.swiftSources/Megrez/4_SpanUnit.swift renamed to Sources/Megrez/4_Segment.swift

@@ -7,28 +7,28 @@
 extension Megrez {
   /// 字詞節點。
   ///
-  /// 一個節點由這些內容組成：幅位長度、索引鍵、以及一組單元圖。幅位長度就是指這個
+  /// 一個節點由這些內容組成：幅節長度、索引鍵、以及一組單元圖。幅節長度就是指這個
   /// 節點在組字器內橫跨了多少個字長。組字器負責構築自身的節點。對於由多個漢字組成
   /// 的詞，組字器會將多個讀音索引鍵合併為一個讀音索引鍵、據此向語言模組請求對應的
   /// 單元圖結果陣列。舉例說，如果一個詞有兩個漢字組成的話，那麼讀音也是有兩個、其
-  /// 索引鍵也是由兩個讀音組成的，那麼這個節點的幅位長度就是 2。
+  /// 索引鍵也是由兩個讀音組成的，那麼這個節點的幅節長度就是 2。
   public class Node: Equatable, Hashable, Codable {
     // MARK: Lifecycle
 
     /// 生成一個字詞節點。
     ///
-    /// 一個節點由這些內容組成：幅位長度、索引鍵、以及一組單元圖。幅位長度就是指這個
+    /// 一個節點由這些內容組成：幅節長度、索引鍵、以及一組單元圖。幅節長度就是指這個
     /// 節點在組字器內橫跨了多少個字長。組字器負責構築自身的節點。對於由多個漢字組成
     /// 的詞，組字器會將多個讀音索引鍵合併為一個讀音索引鍵、據此向語言模組請求對應的
     /// 單元圖結果陣列。舉例說，如果一個詞有兩個漢字組成的話，那麼讀音也是有兩個、其
-    /// 索引鍵也是由兩個讀音組成的，那麼這個節點的幅位長度就是 2。
+    /// 索引鍵也是由兩個讀音組成的，那麼這個節點的幅節長度就是 2。
     /// - Parameters:
     ///   - keyArray: 給定索引鍵陣列，不得為空。
-    ///   - spanLength: 給定幅位長度，一般情況下與給定索引鍵陣列內的索引鍵數量一致。
+    ///   - segLength: 給定幅節長度，一般情況下與給定索引鍵陣列內的索引鍵數量一致。
     ///   - unigrams: 給定單元圖陣列，不得為空。
-    public init(keyArray: [String] = [], spanLength: Int = 0, unigrams: [Megrez.Unigram] = []) {
+    public init(keyArray: [String] = [], segLength: Int = 0, unigrams: [Megrez.Unigram] = []) {
       self.keyArray = keyArray
-      self.spanLength = max(spanLength, 0)
+      self.segLength = max(segLength, 0)
       self.unigrams = unigrams
       self.currentOverrideType = .withNoOverrides
     }
@@ -40,7 +40,7 @@ extension Megrez {
     public init(node: Node) {
       self.overridingScore = node.overridingScore
       self.keyArray = node.keyArray
-      self.spanLength = node.spanLength
+      self.segLength = node.segLength
       self.unigrams = node.unigrams
       self.currentOverrideType = node.currentOverrideType
       self.currentUnigramIndex = node.currentUnigramIndex
@@ -54,28 +54,28 @@ extension Megrez {
     /// 當前狀態下權重最高的單元圖的權重數值。打比方說，如果該節點內的單元圖陣列是
     ///  [("a", -114), ("b", -514), ("c", -1919)] 的話，指定該覆寫行為則會導致該節
     ///  點返回的結果為 ("c", -114)。該覆寫行為多用於諸如使用者半衰記憶模組的建議
-    ///  行為。被覆寫的這個節點的狀態可能不會再被爬軌行為擅自改回。該覆寫行為無法
-    ///  防止其它節點被爬軌函式所支配。這種情況下就需要用到 overridingScore。
-    /// - withHighScore: 將該節點權重覆寫為 overridingScore，使其被爬軌函式所青睞。
+    ///  行為。被覆寫的這個節點的狀態可能不會再被組句行為擅自改回。該覆寫行為無法
+    ///  防止其它節點被組句函式所支配。這種情況下就需要用到 overridingScore。
+    /// - withHighScore: 將該節點權重覆寫為 overridingScore，使其被組句函式所青睞。
     public enum OverrideType: Int, Codable {
       case withNoOverrides = 0
       case withTopUnigramScore = 1
       case withHighScore = 2
     }
 
-    /// 一個用以覆寫權重的數值。該數值之高足以改變爬軌函式對該節點的讀取結果。這裡用
-    /// 「0」可能看似足夠了，但仍會使得該節點的覆寫狀態有被爬軌函式忽視的可能。比方說
+    /// 一個用以覆寫權重的數值。該數值之高足以改變組句函式對該節點的讀取結果。這裡用
+    /// 「0」可能看似足夠了，但仍會使得該節點的覆寫狀態有被組句函式忽視的可能。比方說
     /// 要針對索引鍵「a b c」複寫的資料值為「A B C」，使用大寫資料值來覆寫節點。這時，
-    /// 如果這個獨立的 c 有一個可以拮抗權重的詞「bc」的話，可能就會導致爬軌函式的算法
-    /// 找出「A->bc」的爬軌途徑（尤其是當 A 和 B 使用「0」作為複寫數值的情況下）。這樣
-    /// 一來，「A-B」就不一定始終會是爬軌函式的青睞結果了。所以，這裡一定要用大於 0 的
+    /// 如果這個獨立的 c 有一個可以拮抗權重的詞「bc」的話，可能就會導致組句函式的算法
+    /// 找出「A->bc」的組句途徑（尤其是當 A 和 B 使用「0」作為複寫數值的情況下）。這樣
+    /// 一來，「A-B」就不一定始終會是組句函式的青睞結果了。所以，這裡一定要用大於 0 的
     /// 數（比如野獸常數），以讓「c」更容易單獨被選中。
     public var overridingScore: Double = 114_514
 
     /// 索引鍵陣列。
     public private(set) var keyArray: [String]
-    /// 幅位長度。
-    public private(set) var spanLength: Int
+    /// 幅節長度。
+    public private(set) var segLength: Int
     /// 單元圖陣列。
     public private(set) var unigrams: [Megrez.Unigram]
     /// 該節點目前的覆寫狀態種類。
@@ -127,7 +127,7 @@ extension Megrez {
     public func hash(into hasher: inout Hasher) {
       hasher.combine(overridingScore)
       hasher.combine(keyArray)
-      hasher.combine(spanLength)
+      hasher.combine(segLength)
       hasher.combine(unigrams)
       hasher.combine(currentOverrideType)
       hasher.combine(currentUnigramIndex)
@@ -211,18 +211,18 @@ extension Array where Element == Megrez.Node {
     return (resultA, resultB)
   }
 
-  /// 返回一個辭典，以座標查索引。允許以游標位置查詢其屬於第幾個幅位座標（從 0 開始算）。
+  /// 返回一個辭典，以座標查索引。允許以游標位置查詢其屬於第幾個幅節座標（從 0 開始算）。
   public var cursorRegionMap: [Int: Int] { nodeBorderPointDictPair.cursorRegionMap }
 
-  /// 總讀音單元數量。在絕大多數情況下，可視為總幅位長度。
+  /// 總讀音單元數量。在絕大多數情況下，可視為總幅節長度。
   public var totalKeyCount: Int { map(\.keyArray.count).reduce(0, +) }
 
   /// 根據給定的游標，返回其前後最近的節點邊界。
   /// - Parameter cursor: 給定的游標。
   public func contextRange(ofGivenCursor cursor: Int) -> Range<Int> {
     guard !isEmpty else { return 0 ..< 0 }
-    let lastSpanningLength = reversed()[0].keyArray.count
-    var nilReturn = (totalKeyCount - lastSpanningLength) ..< totalKeyCount
+    let frontestSegLength = reversed()[0].keyArray.count
+    var nilReturn = (totalKeyCount - frontestSegLength) ..< totalKeyCount
     if cursor >= totalKeyCount { return nilReturn } // 防呆
     let cursor = Swift.max(0, cursor) // 防呆
     nilReturn = cursor ..< cursor

Sources/Megrez/5_Node.swift

@@ -8,7 +8,7 @@ import Megrez
 // MARK: - Megrez Extensions for Test Purposes Only.
 
 extension Megrez.Compositor {
-  /// 返回在當前位置的所有候選字詞（以詞音配對的形式）。如果組字器內有幅位、且游標
+  /// 返回在當前位置的所有候選字詞（以詞音配對的形式）。如果組字器內有幅節、且游標
   /// 位於組字器的（文字輸入順序的）最前方（也就是游標位置的數值是最大合規數值）的
   /// 話，那麼這裡會用到 location - 1、以免去在呼叫該函式後再處理的麻煩。
   /// - Remark: 該函式已被淘汰，因為有「無法徹底清除 node-crossing 內容」的故障。