Improve Candidate and CandidateType

Author: bingzheung

CoreIME/Sources/CoreIME/Candidate.swift

@@ -5,15 +5,12 @@ public enum CandidateType: Int {
         /// Plain text. Examples: iPad, macOS
         case text
 
+        /// Note that `Candidate.text.count == 1` not always true
         case emoji
 
-        case emojiSequence
-
-        /// Note that `text.count == 1` not always true
+        /// Note that `Candidate.text.count == 1` not always true
         case symbol
 
-        case symbolSequence
-
         /// macOS Keyboard composed text. Mainly for PunctuationKey.
         case compose
 }
@@ -127,13 +124,19 @@ public struct Candidate: Hashable {
                 return self.type == .cantonese
         }
 
+        /// type != .cantonese
+        public var isNotCantonese: Bool {
+                return self.type != .cantonese
+        }
+
         /// Concatenated by multiple lexicons
         public var isCompound: Bool {
                 return subNotations.isNotEmpty
         }
 
         // Equatable
         public static func ==(lhs: Candidate, rhs: Candidate) -> Bool {
+                guard lhs.type == rhs.type else { return false }
                 if lhs.isCantonese && rhs.isCantonese {
                         return lhs.text == rhs.text && lhs.romanization == rhs.romanization
                 } else {
@@ -151,18 +154,15 @@ public struct Candidate: Hashable {
                         hasher.combine(text)
                 case .emoji:
                         hasher.combine(text)
-                case .emojiSequence:
-                        hasher.combine(text)
                 case .symbol:
                         hasher.combine(text)
-                case .symbolSequence:
-                        hasher.combine(text)
                 case .compose:
                         hasher.combine(text)
                 }
         }
 
-        static func +(lhs: Candidate, rhs: Candidate) -> Candidate {
+        static func +(lhs: Candidate, rhs: Candidate) -> Candidate? {
+                guard lhs.isCantonese && rhs.isCantonese else { return nil }
                 let newText: String = lhs.text + rhs.text
                 let newLexiconText: String = lhs.lexiconText + rhs.lexiconText
                 let newRomanization: String = lhs.romanization + " " + rhs.romanization
@@ -190,7 +190,9 @@ extension Array where Element == Candidate {
 
         /// Returns a new Candidate by concatenating this Candidate sequence.
         /// - Returns: Single, concatenated Candidate.
-        public func joined() -> Candidate {
+        public func joined() -> Candidate? {
+                let isNotAllCantonese: Bool = self.contains(where: \.isNotCantonese)
+                guard !isNotAllCantonese else { return nil }
                 let text: String = map(\.text).joined()
                 let lexiconText: String = map(\.lexiconText).joined()
                 let romanization: String = map(\.romanization).joined(separator: " ")

CoreIME/Sources/CoreIME/Engine.swift

@@ -251,7 +251,7 @@ public struct Engine {
                         guard tailCandidates.isNotEmpty else { return [] }
                         let headCandidates = primary.filter({ $0.input == headText }).prefix(8)
                         let combines = headCandidates.map({ head -> [Candidate] in
-                                return tailCandidates.map({ head + $0 })
+                                return tailCandidates.compactMap({ head + $0 })
                         })
                         return combines.flatMap({ $0 })
                 }

CoreIME/Sources/CoreIME/Segmentor.swift

@@ -138,6 +138,8 @@ public struct Segmentor {
                         }
                 case 4 where text == "mama":
                         return mama
+                case 4 where text == "mami":
+                        return mami
                 default:
                         let rawText: String = text.filter({ !$0.isSeparatorOrTone })
                         let key: Int = rawText.hash
@@ -163,4 +165,5 @@ public struct Segmentor {
         private static let letterO: Segmentation = [[SegmentToken(text: "o", origin: "o")]]
         private static let letterM: Segmentation = [[SegmentToken(text: "m", origin: "m")]]
         private static let mama: Segmentation = [[SegmentToken(text: "ma", origin: "maa"), SegmentToken(text: "ma", origin: "maa")]]
+        private static let mami: Segmentation = [[SegmentToken(text: "ma", origin: "maa"), SegmentToken(text: "mi", origin: "mi")]]
 }

TypeDuck/Candidate/DisplayCandidate.swift

@@ -16,7 +16,7 @@ struct DisplayCandidate: Hashable {
                                 return candidate.notation?.comments ?? []
                         case .text:
                                 return []
-                        case .emoji, .symbol, .emojiSequence, .symbolSequence:
+                        case .emoji, .symbol:
                                 var comments: [Comment] = []
                                 let cantoneseText = candidate.lexiconText
                                 if cantoneseText.isNotEmpty {

TypeDuck/TypeDuckInputController.swift

@@ -211,7 +211,7 @@ final class TypeDuckInputController: IMKInputController {
                         switch bufferText.first {
                         case .none:
                                 if AppSettings.isInputMemoryOn && selectedCandidates.isNotEmpty {
-                                        let concatenated: Candidate = selectedCandidates.joined()
+                                        let concatenated = selectedCandidates.joined()
                                         UserLexicon.handle(concatenated)
                                 }
                                 selectedCandidates = []

TypeDuck/UserLexicon.swift

@@ -25,7 +25,8 @@ struct UserLexicon {
 
         // MARK: - Handle Candidate
 
-        static func handle(_ candidate: Candidate) {
+        static func handle(_ candidate: Candidate?) {
+                guard let candidate else { return }
                 let word: String = candidate.lexiconText
                 let romanization: String = candidate.romanization
                 let id: Int64 = Int64((word + romanization).hash)