hex/ios/HEXShared/DictationLanguageSwitch.swift
Dax 3bb5e5702d
iOS: add a Greeklish experiment for Greek dictation (#2366)
* iOS: add a Greeklish experiment for Greek dictation

Greeklish writes Greek dictation in Latin letters before the rest of the
pipeline, like Hinglish does for Hindi: accents are stripped, digraphs and
letters are transliterated by rule, and a diaeresis keeps vowels apart.
It is off by default under Settings > Experiments (experiments.greeklish,
--experiment-greeklish), applies only to Greek (el / el-GR), renames Greek in
the language menus and offers it on the keyboard's quick switch. A dictation
that translates keeps its Greek letters, as Hinglish keeps Devanagari, and is
romanized only when it goes in as spoken. The app, its keyboard handoff and
in-keyboard dictation all read the same App Group setting.

* iOS: fix Greeklish punctuation, one-letter caps, and Greek ranges

Speak Greek question marks and ano teleia are usually normalized to a plain
";" and "·", so a ";" directly after a Greek letter now becomes "?" and a
"·" directly after one becomes ";", while both stay as written after Latin.
A one-letter Greek word only takes its capital ("Θ' αργήσω" -> "Th'
argiso"), instead of reading as all caps. The Greek letter test now covers
only the Greek block's letters (not Coptic or U+03F6) and the polytonic
letters (not its spacing marks), and the Greeklish tests move to their own
file.

* iOS: read Greek letter variants and document Greeklish

Greeklish reads the variant Greek letters fonts and keyboards produce (ϐ ϑ ϕ
ϖ ϰ ϱ ϲ ϵ) as their base letters, the feature map lists the experiment beside
Hinglish, and the test settings use their own suite and clean it up.

* iOS: split the Experiments body so it type-checks

Adding the Greeklish row pushed the Experiments page's one modifier chain past
what the Swift compiler would type-check in reasonable time. Split it into a
page and three short chains, with no behavior change.
2026-11-22 08:51:48 -05:00

273 lines
13 KiB
Swift
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import Foundation
/// The keyboard's quick dictation-language switch: which languages it offers and the names
/// it shows for them. The choice is Settings › Dictation language (`LanguageSettings`).
nonisolated enum DictationLanguageSwitch {
static let maxChoices = 5
/// Up to five languages, best first: the one set now, the ones picked recently, Hindi while
/// Experiments › Hinglish is on and Greek while Greeklish is (shown as Hinglish and
/// Greeklish), then the iPhone's preferred languages.
/// Each is matched to a language Apple Speech has (`supported`, BCP 47) when that list is
/// known, and dropped when it has none. One variant per language: the first of es-US and
/// es-ES wins, so no two chips mean the same language (`variantKey`), except Chinese,
/// whose variants stay apart (Mandarin's zh-CN, Taiwan's zh-TW and Cantonese's zh-HK each
/// get a chip). Languages taken off the switch (`removed`, as it listed them) stay off,
/// except the one set now. `region` is the iPhone's Region, which Spanish without one of
/// its own follows.
static func choices(
current: String?,
recent: [String],
preferred: [String],
supported: [String],
hinglish: Bool = false,
greeklish: Bool = false,
removed: [String] = [],
region: String? = Locale.current.region?.identifier
) -> [String] {
var result: [String] = []
var languages = Set<String>()
if let current, let match = supportedMatch(for: current, in: supported, region: region) {
languages.insert(variantKey(of: match) ?? match)
result.append(match)
}
func offer(_ identifier: String) {
guard result.count < maxChoices,
let match = supportedMatch(for: identifier, in: supported, region: region),
!removed.contains(match),
languages.insert(variantKey(of: match) ?? match).inserted else { return }
result.append(match)
}
let offered = (hinglish ? [HinglishSettings.language] : [])
+ (greeklish ? [GreeklishSettings.language] : [])
for identifier in recent + offered + preferred {
guard result.count < maxChoices else { break }
offer(identifier)
}
return result
}
/// The keyboard's More languages: every other language Apple Speech has, the iPhone's
/// preferred ones first (with their other regions), then the rest by name.
static func more(
choices: [String],
preferred: [String],
supported: [String],
hinglish: HinglishSettings = HinglishSettings(),
greeklish: GreeklishSettings = GreeklishSettings(),
region: String? = Locale.current.region?.identifier
) -> [String] {
guard !supported.isEmpty else { return [] }
var first: [String] = []
for identifier in preferred {
guard let match = supportedMatch(for: identifier, in: supported, region: region),
!choices.contains(match), !first.contains(match) else { continue }
first.append(match)
}
let codes = preferred.compactMap { Locale(identifier: $0).language.languageCode?.identifier }
let rest = supported.filter { !choices.contains($0) && !first.contains($0) }
let names = nativeNames(for: supported, hinglish: hinglish, greeklish: greeklish)
func byName(_ a: String, _ b: String) -> Bool {
(names[a] ?? a).localizedStandardCompare(names[b] ?? b) == .orderedAscending
}
func rank(_ id: String) -> Int? {
Locale(identifier: id).language.languageCode.flatMap { codes.firstIndex(of: $0.identifier) }
}
let regions = rest.filter { rank($0) != nil }.sorted { a, b in
rank(a) == rank(b) ? byName(a, b) : rank(a)! < rank(b)!
}
return first + regions + rest.filter { rank($0) == nil }.sorted(by: byName)
}
/// The supported locale for an identifier: the same region, else the language's usual
/// region ("es" is Spain's), else any. Nynorsk maps to Bokmål. With no list, itself.
/// Spanish follows `spanishCandidates`: a Latin American, United States or other region
/// Apple doesn't offer is the Americas' (es-US, then es-MX) before Spain's, and plain
/// Spanish is whichever of those the iPhone's `region` calls for.
static func supportedMatch(
for identifier: String,
in supported: [String],
region: String? = Locale.current.region?.identifier
) -> String? {
let wanted = Locale(identifier: identifier)
guard !supported.isEmpty else { return wanted.identifier(.bcp47) }
var code = wanted.language.languageCode?.identifier
if code == "nn" || code == "no" { code = "nb" }
let candidates = supported.filter { Locale(identifier: $0).language.languageCode?.identifier == code }
guard !candidates.isEmpty, let code else { return nil }
if code == "es" {
for fallback in spanishCandidates(for: identifier, region: region) {
let wantedRegion = Locale(identifier: fallback).region?.identifier
if let exact = candidates.first(where: { Locale(identifier: $0).region?.identifier == wantedRegion }) {
return exact
}
}
return candidates.first
}
if let region = wanted.region?.identifier,
let exact = candidates.first(where: { Locale(identifier: $0).region?.identifier == region }) {
return exact
}
let usual = Locale.Language(identifier: Locale.Language(identifier: code).maximalIdentifier).region?.identifier
return candidates.first { Locale(identifier: $0).region?.identifier == usual } ?? candidates.first
}
/// The iPhone's regions whose Spanish Apple Speech calls Latin American: es-US serves the
/// United States, Puerto Rico and Latin America, and Mexico has es-MX.
private static let latinAmericanSpanishRegions: Set<String> = [
"419", "AR", "BO", "CL", "CO", "CR", "CU", "DO", "EC", "SV", "GT", "HN", "NI", "PA",
"PY", "PE", "PR", "US", "UY", "VE",
]
/// The Spanish variant the iPhone's Region dictates in when nothing else names one: es-MX
/// for Mexico, es-US for the United States, Puerto Rico and Latin America, else es-ES.
/// `region` is `Locale.current.region` where the caller has not been handed one.
static func spanish(forRegion region: String?) -> String {
let code = region?.uppercased()
if code == "MX" { return "es-MX" }
if let code, latinAmericanSpanishRegions.contains(code) { return "es-US" }
return "es-ES"
}
/// Apple's Spanish locales for an identifier, best first: its own (Apple may have it), then
/// es-US and es-MX for a region that is neither Spain's nor Equatorial Guinea's, and Spain's
/// es-ES. Plain Spanish (no region) starts from the iPhone's Region's variant.
static func spanishCandidates(
for identifier: String,
region: String? = Locale.current.region?.identifier
) -> [String] {
let wanted = Locale(identifier: identifier).region?.identifier
var result: [String] = []
if let wanted {
result = ["es-\(wanted)"]
if wanted == "ES" || wanted == "GQ" {
result.append("es-ES")
} else {
result += ["es-US", "es-MX", "es-ES"]
}
} else {
result = [spanish(forRegion: region), "es-US", "es-MX", "es-ES"]
}
var seen = Set<String>()
return result.filter { seen.insert(Locale(identifier: $0).identifier(.bcp47)).inserted }
}
/// The language an identifier belongs to, with Apple's aliases: Nynorsk and Norwegian are
/// Bokmål, and a script (Srpski's Latin) stays out of it.
static func languageCode(of identifier: String) -> String? {
let code = Locale(identifier: identifier).language.languageCode?.identifier
return code == "nn" || code == "no" ? "nb" : code
}
/// Which languages count as one on the switch and in the recents: the language a variant
/// belongs to, as `languageCode` names it, so es-US and es-ES are one and picking either
/// drops the other. Chinese is never one: the written language splits by script and region
/// (Mandarin's zh-CN and Taiwan's zh-TW), and Cantonese (zh-HK, yue) is a language of its
/// own, so each keeps its full identifier and its own chip.
static func variantKey(of identifier: String) -> String? {
guard let code = languageCode(of: identifier) else { return nil }
guard code == "zh" || code == "yue" else { return code }
return Locale(identifier: identifier).identifier(.bcp47)
}
/// The language's own short name: "English", "Norsk", "Español", "Deutsch", "עברית",
/// "Русский", and "Srpski" in its script for Serbian (Latin). Hindi is "Hinglish" while
/// Experiments › Hinglish writes it in Latin letters, and Greek is "Greeklish" while
/// Greeklish does. `supported` (what Apple Speech has
/// here) adds the region where it offers more than one of the language, as Apple's own
/// keyboards do: "Español (US)" while it also has Spain's, "English (GB)"; Norwegian stays
/// "Norsk" because it has only one.
static func nativeName(for identifier: String) -> String {
nativeName(for: identifier, supported: [])
}
static func nativeName(for identifier: String, hinglish: HinglishSettings) -> String {
nativeName(for: identifier, supported: [], hinglish: hinglish)
}
static func nativeName(for identifier: String, greeklish: GreeklishSettings) -> String {
nativeName(for: identifier, supported: [], greeklish: greeklish)
}
static func nativeName(
for identifier: String,
supported: [String],
hinglish: HinglishSettings = HinglishSettings(),
greeklish: GreeklishSettings = GreeklishSettings()
) -> String {
nativeName(for: identifier, among: supported, hinglish: hinglish, greeklish: greeklish)
}
/// Native names for a list, with the region code only where two share a language:
/// "English (US)", "English (GB)", "Norsk". `supported` is Apple Speech's list here, so a
/// language with another region it doesn't show still names the one in the list.
static func nativeNames(
for identifiers: [String],
hinglish: HinglishSettings = HinglishSettings(),
greeklish: GreeklishSettings = GreeklishSettings()
) -> [String: String] {
nativeNames(for: identifiers, supported: [], hinglish: hinglish, greeklish: greeklish)
}
static func nativeNames(
for identifiers: [String],
supported: [String],
hinglish: HinglishSettings = HinglishSettings(),
greeklish: GreeklishSettings = GreeklishSettings()
) -> [String: String] {
let variants = supported.isEmpty ? identifiers : supported
var names: [String: String] = [:]
for identifier in identifiers {
names[identifier] = nativeName(
for: identifier,
among: variants,
hinglish: hinglish,
greeklish: greeklish
)
}
return names
}
private static func nativeName(
for identifier: String,
among variants: [String],
hinglish: HinglishSettings,
greeklish: GreeklishSettings
) -> String {
let name = nativeLanguageName(for: identifier, hinglish: hinglish, greeklish: greeklish)
guard showsRegion(for: identifier, among: variants),
let region = Locale(identifier: identifier).region?.identifier else { return name }
return "\(name) (\(region))"
}
private static func nativeLanguageName(
for identifier: String,
hinglish: HinglishSettings,
greeklish: GreeklishSettings
) -> String {
if let name = hinglish.name(for: identifier) { return name }
if let name = greeklish.name(for: identifier) { return name }
let language = Locale(identifier: identifier).language
let code = language.languageCode?.identifier ?? identifier
switch code {
case "nb", "no": return "Norsk"
case "nn": return "Nynorsk"
default: break
}
let own = Locale(identifier: language.script.map { "\(code)-\($0.identifier)" } ?? code)
guard let name = own.localizedString(forLanguageCode: code) else { return identifier }
return name.prefix(1).uppercased(with: own) + name.dropFirst()
}
/// Whether Apple Speech has more than one region of the language `identifier` belongs to.
private static func showsRegion(for identifier: String, among supported: [String]) -> Bool {
let code = languageCode(of: identifier) ?? identifier
var regions = Set<String>()
for other in supported {
guard languageCode(of: other) == code,
let region = Locale(identifier: other).region?.identifier else { continue }
regions.insert(region)
}
return regions.count > 1
}
}