Natural Language

import NaturalLanguageimport Translation

import NaturalLanguage
func tokenizeWords(in text: String) -> [String] {    let tokenizer = NLTokenizer(unit: .word)    tokenizer.string = text
    let range = text.startIndex..<text.endIndex    return tokenizer.tokens(for: range).map { String(text[$0]) }}

let tokenizer = NLTokenizer(unit: .word)tokenizer.string = text
tokenizer.enumerateTokens(in: text.startIndex..<text.endIndex) { range, attributes in    if attributes.contains(.numeric) {        print("Number: \(text[range])")    }    return true // continue enumeration}

func detectLanguage(for text: String) -> NLLanguage? {    NLLanguageRecognizer.dominantLanguage(for: text)}
// Multiple hypotheses with confidence scoresfunc languageHypotheses(for text: String, max: Int = 5) -> [NLLanguage: Double] {    let recognizer = NLLanguageRecognizer()    recognizer.processString(text)    return recognizer.languageHypotheses(withMaximum: max)}

let recognizer = NLLanguageRecognizer()recognizer.languageConstraints = [.english, .french, .spanish]recognizer.processString(text)let detected = recognizer.dominantLanguage

func tagPartsOfSpeech(in text: String) -> [(String, NLTag)] {    let tagger = NLTagger(tagSchemes: [.lexicalClass])    tagger.string = text
    var results: [(String, NLTag)] = []    let range = text.startIndex..<text.endIndex    let options: NLTagger.Options = [.omitPunctuation, .omitWhitespace]
    tagger.enumerateTags(in: range, unit: .word, scheme: .lexicalClass, options: options) { tag, tokenRange in        if let tag {            results.append((String(text[tokenRange]), tag))        }        return true    }    return results}

func extractEntities(from text: String) -> [(String, NLTag)] {    let tagger = NLTagger(tagSchemes: [.nameType])    tagger.string = text
    var entities: [(String, NLTag)] = []    let options: NLTagger.Options = [.omitPunctuation, .omitWhitespace, .joinNames]
    tagger.enumerateTags(        in: text.startIndex..<text.endIndex,        unit: .word,        scheme: .nameType,        options: options    ) { tag, tokenRange in        if let tag, tag != .other {            entities.append((String(text[tokenRange]), tag))        }        return true    }    return entities}// NLTag values: .personalName, .placeName, .organizationName

func sentimentScore(for text: String) -> Double? {    let tagger = NLTagger(tagSchemes: [.sentimentScore])    tagger.string = text
    let (tag, _) = tagger.tag(        at: text.startIndex,        unit: .paragraph,        scheme: .sentimentScore    )    return tag.flatMap { Double($0.rawValue) }}

func wordSimilarity(_ word1: String, _ word2: String) -> Double? {    guard let embedding = NLEmbedding.wordEmbedding(for: .english) else { return nil }    return embedding.distance(between: word1, and: word2, distanceType: .cosine)}
func findSimilarWords(to word: String, count: Int = 5) -> [(String, Double)] {    guard let embedding = NLEmbedding.wordEmbedding(for: .english) else { return [] }    return embedding.neighbors(for: word, maximumCount: count, distanceType: .cosine)}

func sentenceSimilarity(_ s1: String, _ s2: String) -> Double? {    guard let embedding = NLEmbedding.sentenceEmbedding(for: .english) else { return nil }    return embedding.distance(between: s1, and: s2, distanceType: .cosine)}

import SwiftUIimport Translation
struct TranslatableView: View {    @State private var showTranslation = false    let text = "Hello, how are you?"
    var body: some View {        Button { showTranslation = true } label: {            Text(text)        }        .buttonStyle(.plain)        .translationPresentation(            isPresented: $showTranslation,            text: text        )    }}

struct TranslatingView: View {    @State private var translatedText = ""    @State private var translationErrorMessage: String?    @State private var configuration: TranslationSession.Configuration?
    var body: some View {        VStack {            Text(translatedText)            Button("Translate") {                configuration = .init(source: Locale.Language(identifier: "en"),                                      target: Locale.Language(identifier: "es"))            }        }        .translationTask(configuration) { session in            do {                let response = try await session.translate("Hello, world!")                await MainActor.run {                    translatedText = response.targetText                    translationErrorMessage = nil                }            } catch {                let message = error.localizedDescription                await MainActor.run {                    translationErrorMessage = message                }            }        }    }}

.translationTask(configuration) { session in    do {        let requests = texts.enumerated().map { index, text in            TranslationSession.Request(sourceText: text,                                       clientIdentifier: "\(index)")        }        let responses = try await session.translations(from: requests)        for response in responses {            print("\(response.sourceText) -> \(response.targetText)")        }    } catch {        // Handle cancellation, unsupported languages, or download refusal.    }}

let availability = LanguageAvailability()let status = await availability.status(    from: Locale.Language(identifier: "en"),    to: Locale.Language(identifier: "ja"))switch status {case .installed: break    // Ready to translate offlinecase .supported: break    // Needs downloadcase .unsupported: break  // Language pair not available}

// WRONGlet sharedTagger = NLTagger(tagSchemes: [.lexicalClass])DispatchQueue.concurrentPerform(iterations: 10) { _ in    sharedTagger.string = someText  // Data race}
// CORRECTawait withTaskGroup(of: Void.self) { group in    for _ in 0..<10 {        group.addTask {            let tagger = NLTagger(tagSchemes: [.lexicalClass])            tagger.string = someText            // process...        }    }}

// WRONG: Trying to do NER with raw Core MLlet coreMLModel = try MLModel(contentsOf: modelURL)
// CORRECT: Use NLTagger for built-in NERlet tagger = NLTagger(tagSchemes: [.nameType])
// Or load a custom Core ML model via NLModellet nlModel = try NLModel(mlModel: coreMLModel)tagger.setModels([nlModel], forTagScheme: .nameType)

// WRONG: Force unwraplet embedding = NLEmbedding.wordEmbedding(for: .japanese)!
// CORRECT: Handle nilguard let embedding = NLEmbedding.wordEmbedding(for: .japanese) else {    // Embedding not available for this language    return}

// WRONG: New tagger per wordfor word in words {    let tagger = NLTagger(tagSchemes: [.lexicalClass])    tagger.string = word}
// CORRECT: Set string once, enumeratelet tagger = NLTagger(tagSchemes: [.lexicalClass])tagger.string = fullTexttagger.enumerateTags(in: fullText.startIndex..<fullText.endIndex,                     unit: .word, scheme: .lexicalClass, options: []) { tag, range in    return true}

// WRONG: Detect language of a single wordlet lang = NLLanguageRecognizer.dominantLanguage(for: "chat")  // French or English?
// CORRECT: Provide contextlet recognizer = NLLanguageRecognizer()recognizer.languageHints = [.english: 0.8, .french: 0.2]recognizer.processString("chat")