Make Unigram into a class instead to reduce heap.

Author: ShikiSuen

Sources/Megrez/1_Compositor.swift

@@ -199,9 +199,10 @@ extension Megrez {
     ///   - direction: 指定方向（相對於文字輸入方向而言）。
     ///   - isMarker: 是否為標記游標。
     public func isCursorAtEdge(direction: TypingDirection, isMarker: Bool = false) -> Bool {
+      let pos = isMarker ? marker : cursor
       switch direction {
-      case .front: cursor == length
-      case .rear: cursor == 0
+      case .front: return pos == length
+      case .rear: return pos == 0
       }
     }
 
@@ -226,7 +227,7 @@ extension Megrez {
         return false
       }
       pos += delta
-      if isCursorCuttingChar(isMarker: true) {
+      if isCursorCuttingChar(isMarker: isMarker) {
         return jumpCursorBySegment(to: direction, isMarker: isMarker)
       }
       return true
@@ -353,12 +354,19 @@ extension Megrez {
     )
       -> [Megrez.Unigram] {
       if let cached = cache[keyArray] {
-        // 如果將來 Gram 變成 Class 的話，不要與之前的結果共用記憶體位置。
-        return cached
-      }
-      return langModel.unigramsFor(keyArray: keyArray).sorted {
-        $0.score > $1.score
+        return cached.map(\.copy)
       }
+      let canonical = langModel
+        .unigramsFor(keyArray: keyArray)
+        .map { source -> Megrez.Unigram in
+          if source.keyArray == keyArray {
+            return source.copy
+          }
+          return source.copy(withKeyArray: keyArray)
+        }
+        .sorted { $0.score > $1.score }
+      cache[keyArray] = canonical
+      return canonical.map(\.copy)
     }
   }
 }

Sources/Megrez/2_PathFinder.swift

@@ -68,7 +68,6 @@ extension Megrez {
       while currentPos > 0 {
         guard let node = parent[currentPos] else { break }
         let insertable = Megrez.GramInPath(
-          keyArray: node.keyArray,
           gram: node.currentUnigram,
           isOverridden: node.isOverridden
         )

Sources/Megrez/5_Node.swift

@@ -43,7 +43,7 @@ extension Megrez {
       self.overridingScore = node.overridingScore
       self.keyArray = node.keyArray
       self.segLength = node.segLength
-      self.unigrams = node.unigrams
+      self.unigrams = node.unigrams.map(\.copy)
       self.currentOverrideType = node.currentOverrideType
       self.currentUnigramIndex = node.currentUnigramIndex
     }

Sources/Megrez/7_Unigram.swift

@@ -5,45 +5,82 @@
 // MARK: - Megrez.Unigram
 
 extension Megrez {
-  /// 語言模型的基礎資料單位結構。
-  public struct Unigram: Equatable, CustomStringConvertible, Hashable, Codable {
+  /// 語言模型的基礎資料單位類型。
+  public final class Unigram: Codable, CustomStringConvertible, Equatable, Hashable {
     // MARK: Lifecycle
 
-    /// 建立語言模型基礎資料單位副本。基礎資料單位由詞彙內容與統計權重組成。
+    /// 建立語言模型基礎資料單位副本。基礎資料單位由索引鍵陣列、詞彙內容與統計權重組成。
     /// - Parameters:
+    ///   - keyArray: 對應的索引鍵陣列。
     ///   - value: 詞彙內容。
     ///   - score: 統計權重（雙精度浮點數）。
-    public init(value: String = "", score: Double = 0) {
+    public init(keyArray: [String] = [], value: String = "", score: Double = 0) {
+      self.keyArray = keyArray
       self.value = value
       self.score = score
     }
 
+    public required init(from decoder: any Decoder) throws {
+      let container = try decoder.container(keyedBy: CodingKeys.self)
+      self.keyArray = try container.decode([String].self, forKey: .keyArray)
+      self.value = try container.decode(String.self, forKey: .value)
+      self.score = try container.decode(Double.self, forKey: .score)
+    }
+
     // MARK: Public
 
+    /// 對應的索引鍵陣列。
+    public let keyArray: [String]
     /// 詞彙內容，可以是單字或詞組。
-    public var value: String
+    public let value: String
     /// 統計權重。
-    public var score: Double
+    public let score: Double
+
+    /// 段長（索引鍵陣列的元素數量）。
+    public var segLength: Int { keyArray.count }
+
+    /// 檢查是否「讀音字長與候選字字長不一致」。
+    public var isReadingMismatched: Bool { keyArray.count != value.count }
 
     /// 將當前單元圖列印成一個字串。
     public var description: String {
       "(" + value.description + "," + String(score) + ")"
     }
 
-    public static func == (lhs: Self, rhs: Self) -> Bool {
-      lhs.hashValue == rhs.hashValue
+    /// 單元圖的淺層複製品（保持相同的索引鍵陣列）。
+    public var copy: Unigram { copy(withKeyArray: nil) }
+
+    public static func == (lhs: Unigram, rhs: Unigram) -> Bool {
+      lhs.keyArray == rhs.keyArray && lhs.value == rhs.value && lhs.score == rhs.score
     }
 
-    public static func < (lhs: Self, rhs: Self) -> Bool {
-      lhs.value < rhs.value || (lhs.value == rhs.value && lhs.score < rhs.score)
+    /// 建立一個新的單元圖副本。
+    /// - Parameter keyArrayOverride: 若指定，則使用新的索引鍵陣列。
+    /// - Returns: 單元圖副本。
+    public func copy(withKeyArray keyArrayOverride: [String]? = nil) -> Unigram {
+      .init(keyArray: keyArrayOverride ?? keyArray, value: value, score: score)
     }
 
-    /// 做為預設雜湊函式。
-    /// - Parameter hasher: 目前物件的雜湊碼。
     public func hash(into hasher: inout Hasher) {
+      hasher.combine(keyArray)
       hasher.combine(value)
       hasher.combine(score)
     }
+
+    public func encode(to encoder: any Encoder) throws {
+      var container = encoder.container(keyedBy: CodingKeys.self)
+      try container.encode(keyArray, forKey: .keyArray)
+      try container.encode(value, forKey: .value)
+      try container.encode(score, forKey: .score)
+    }
+
+    // MARK: Private
+
+    private enum CodingKeys: String, CodingKey {
+      case keyArray
+      case value
+      case score
+    }
   }
 }
 

Sources/Megrez/8_GramInPath.swift

@@ -12,23 +12,21 @@ extension Megrez {
   public struct GramInPath: Codable, Hashable {
     // MARK: Lifecycle
 
-    public init(keyArray: [String], gram: Unigram, isOverridden: Bool) {
-      self.keyArray = keyArray
+    public init(gram: Unigram, isOverridden: Bool) {
       self.gram = gram
       self.isOverridden = isOverridden
-      self.isReadingMismatched = keyArray.count != gram.value.count
     }
 
     // MARK: Public
 
     public let gram: Unigram
     public let isOverridden: Bool
-    public let keyArray: [String]
-    public let isReadingMismatched: Bool
 
+    public var keyArray: [String] { gram.keyArray }
     public var value: String { gram.value }
     public var score: Double { gram.score }
-    public var segLength: Int { keyArray.count }
+    public var segLength: Int { gram.segLength }
+    public var isReadingMismatched: Bool { gram.isReadingMismatched }
 
     /// 該節點當前狀態所展示的鍵值配對。
     public var asCandidatePair: KeyValuePaired {
@@ -165,7 +163,7 @@ extension Array where Element == Megrez.GramInPath {
     }
     guard let perceptedGIP else { return nil }
     var arrGIPs = self
-    while arrGIPs.last?.gram != perceptedGIP.gram { arrGIPs.removeLast() }
+    while arrGIPs.last?.gram !== perceptedGIP.gram { arrGIPs.removeLast() }
     var isHead = true
     var outputCells = [String]()
     loopProc: while !arrGIPs.isEmpty, let frontendPair = arrGIPs.last {

Tests/MegrezTests/SimpleLM.swift

@@ -54,17 +54,31 @@ class SimpleLM: LangModelProtocol {
       let col0 = String(linestream[0])
       let col1 = String(linestream[1])
       let col2 = Double(linestream[2]) ?? 0.0
-      let u = Megrez.Unigram(value: swapKeyValue ? col0 : col1, score: col2)
-      mutDatabase[swapKeyValue ? col1 : col0, default: []].append(u)
+      let key = swapKeyValue ? col1 : col0
+      let value = swapKeyValue ? col0 : col1
+      let keyArray = separatorComponents(from: key)
+      let u = Megrez.Unigram(keyArray: keyArray, value: value, score: col2)
+      mutDatabase[key, default: []].append(u)
     }
   }
+
+  // MARK: Private
+
+  private func separatorComponents(from key: String) -> [String] {
+    if separator.isEmpty {
+      return key.map(\.description)
+    }
+    return key
+      .components(separatedBy: separator)
+      .filter { !$0.isEmpty }
+  }
 }
 
 // MARK: - MockLM
 
 class MockLM: LangModelProtocol {
   func unigramsFor(keyArray: [String]) -> [Megrez.Unigram] {
-    [Megrez.Unigram(value: keyArray.joined(), score: -1)]
+    [Megrez.Unigram(keyArray: keyArray, value: keyArray.joined(), score: -1)]
   }
 
   func hasUnigramsFor(keyArray: [String]) -> Bool {