How to Build a Spelling Practice App in SwiftUI

import SwiftData
import Foundation

@Model
final class SpellingWord {
    var text: String
    var category: String
    var timesAttempted: Int
    var timesCorrect: Int
    var addedAt: Date

    init(text: String, category: String = "General") {
        self.text = text
        self.category = category
        self.timesAttempted = 0
        self.timesCorrect = 0
        self.addedAt = .now
    }

    var accuracy: Double {
        guard timesAttempted > 0 else { return 0 }
        return Double(timesCorrect) / Double(timesAttempted)
    }

    var needsPractice: Bool {
        timesAttempted == 0 || accuracy < 0.8
    }
}

struct DrillView: View {
    @Environment(\.modelContext) private var context
    @Query(sort: \SpellingWord.accuracy) private var words: [SpellingWord]
    @State private var engine = SpellingDrillEngine()
    @State private var index = 0
    @State private var input = ""
    @State private var lastCorrect: Bool? = nil
    @FocusState private var fieldFocused: Bool

    var current: SpellingWord? { words.isEmpty ? nil : words[index % words.count] }

    var body: some View {
        VStack(spacing: 24) {
            ProgressView(value: Double(index), total: Double(max(words.count, 1)))
                .padding(.horizontal)
            Spacer()
            Button { current.map { engine.speak($0.text) } } label: {
                Image(systemName: "speaker.wave.3.fill")
                    .font(.system(size: 72))
                    .foregroundStyle(lastCorrect == false ? .red : .blue)
            }
            .buttonStyle(.plain)
            Text("Tap to hear the word")
                .font(.caption).foregroundStyle(.secondary)
            TextField("Type spelling here…", text: $input)
                .textFieldStyle(.roundedBorder)
                .autocorrectionDisabled()
                .textInputAutocapitalization(.never)
                .focused($fieldFocused)
                .padding(.horizontal, 32)
            Button("Check") { checkAnswer() }
                .buttonStyle(.borderedProminent)
                .disabled(input.trimmingCharacters(in: .whitespaces).isEmpty)
            Spacer()
        }
        .onAppear { fieldFocused = true; current.map { engine.speak($0.text) } }
    }
}

import AVFoundation
import Observation

@Observable
final class SpellingDrillEngine {
    private let synth = AVSpeechSynthesizer()
    var score = 0
    var streak = 0

    func speak(_ word: String, slow: Bool = false) {
        synth.stopSpeaking(at: .immediate)
        let utt = AVSpeechUtterance(string: word)
        utt.voice = AVSpeechSynthesisVoice(language: "en-US")
        utt.rate = slow ? 0.3 : AVSpeechUtteranceDefaultSpeechRate * 0.8
        utt.postUtteranceDelay = 0.1
        synth.speak(utt)
    }

    func spellAloud(_ word: String) {
        let letters = word.map(String.init).joined(separator: " ")
        speak(letters, slow: true)
    }

    @discardableResult
    func evaluate(_ input: String, against word: SpellingWord) -> Bool {
        let correct = input.trimmingCharacters(in: .whitespaces)
            .lowercased() == word.text.lowercased()
        word.timesAttempted += 1
        if correct {
            word.timesCorrect += 1
            score += streak >= 3 ? 20 : 10
            streak += 1
        } else {
            streak = 0
        }
        return correct
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>NSPrivacyTracking</key><false/>
  <key>NSPrivacyTrackingDomains</key><array/>
  <key>NSPrivacyCollectedDataTypes</key><array/>
  <key>NSPrivacyAccessedAPITypes</key>
  <array>
    <dict>
      <key>NSPrivacyAccessedAPIType</key>
      <string>NSPrivacyAccessedAPICategoryUserDefaults</string>
      <key>NSPrivacyAccessedAPITypeReasons</key>
      <array><string>CA92.1</string></array>
    </dict>
  </array>
</dict>
</plist>