// Actor isolation
actor BankAccount {
    private var balance: Decimal = 0
    func deposit(_ amount: Decimal) { balance += amount }
    func withdraw(_ amount: Decimal) throws -> Decimal {
        guard balance >= amount else { throw BankError.insufficientFunds }
        balance -= amount; return amount
    }
}

@MainActor class ViewModel: ObservableObject {
    @Published var items: [Item] = []
    func refresh() async { items = await fetchItems() }
}

// Async/await
func fetchUser(id: Int) async throws -> User {
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// Parallel with async let
async let user = fetchUser(id: 1)
async let posts = fetchPosts()
let data = try await (user, posts)

// Dynamic with TaskGroup
func fetchAll(ids: [Int]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in ids { group.addTask { try await fetchUser(id: id) } }
        return try await group.reduce(into: []) { $0.append($1) }
    }
}

// Sendable
struct UserData: Sendable { let id: Int; let name: String }
final class ThreadSafeCache: @unchecked Sendable {
    private let lock = NSLock()
    private var storage: [String: Any] = [:]
    func get(_ key: String) -> Any? { lock.lock(); defer { lock.unlock() }; return storage[key] }
}

enum ValidationError: Error, LocalizedError {
    case invalidEmail, passwordTooShort(minimum: Int)
    var errorDescription: String? {
        switch self {
        case .invalidEmail: return "Invalid email"
        case .passwordTooShort(let min): return "Min \(min) chars"
        }
    }
}

func validate(_ user: UserInput) throws {
    guard user.email.contains("@") else { throw ValidationError.invalidEmail }
    guard user.password.count >= 8 else { throw ValidationError.passwordTooShort(minimum: 8) }
}

let result = Result { try riskyOperation() }  // Deferred handling

protocol Repository {
    associatedtype Entity: Identifiable
    func fetch(id: Entity.ID) async throws -> Entity?
    func save(_ entity: Entity) async throws
}

func findDuplicates<T: Hashable>(in array: [T]) -> Set<T> {
    var seen = Set<T>(), duplicates = Set<T>()
    for el in array { if seen.contains(el) { duplicates.insert(el) } else { seen.insert(el) } }
    return duplicates
}

func makeShape() -> some Shape { Circle() }  // Single concrete type
func makeAny() -> any Shape { Circle() }     // Any conforming type

class Parent { var child: Child? }
class Child { weak var parent: Parent? }  // Break cycle

class ViewController {
    func setup() {
        onComplete = { [weak self] in self?.handleCompletion() }  // Capture list
    }
}

class CreditCard { unowned let customer: Customer }  // Guaranteed lifetime only

// swift-tools-version: 6.0
let package = Package(
    name: "MyLib",
    platforms: [.macOS(.v14), .iOS(.v17)],
    products: [.library(name: "MyLib", targets: ["MyLib"])],
    dependencies: [.package(url: "https://github.com/apple/swift-async-algorithms", from: "1.0.0")],
    targets: [
        .target(name: "MyLib", dependencies: [.product(name: "AsyncAlgorithms", package: "swift-async-algorithms")]),
        .testTarget(name: "MyLibTests", dependencies: ["MyLib"])
    ]
)

var buffer: InlineArray<64, UInt8> = .init(repeating: 0)  // Stack allocated
func process(_ span: Span<Int>) { for v in span { print(v) } }  // ~400% faster
nonisolated func pureComputation(_ x: Int) -> Int { x * 2 }  // Default MainActor isolation

import Testing

@Test func addition() { #expect(2 + 2 == 4) }
@Test func async() async throws { let data = try await fetchData(); #expect(data.count > 0) }

@Suite("Auth") struct AuthTests {
    @Test func login() async throws {
        let result = try await auth.login(user: "test", pass: "pass")
        #expect(result.isAuthenticated)
    }
}

@Test("Emails", arguments: ["a@b.com", "test@x.org"])
func validEmail(_ email: String) { #expect(EmailValidator.isValid(email)) }

@Test(.enabled(if: FeatureFlags.new)) func conditional() { }
@Test(.timeLimit(.minutes(1))) func limited() async { }
@Test func unwrap() async throws { let user = try #require(await fetchUser(id: 1)); #expect(user.name == "Alice") }

@Observable class Settings { var theme: Theme = .light; var fontSize: Int = 14 }
withObservationTracking { print(settings.theme) } onChange: { print("Changed") }

@OptionSet<UInt8> struct Permissions { private enum Options: Int { case read, write, execute } }

// Codable
struct User: Codable { let id: Int; let name: String; let createdAt: Date }
let encoder = JSONEncoder(); encoder.dateEncodingStrategy = .iso8601
let decoder = JSONDecoder(); decoder.keyDecodingStrategy = .convertFromSnakeCase

// Custom keys
struct Product: Codable {
    let productName: String
    enum CodingKeys: String, CodingKey { case productName = "product_name" }
}

let phone = /\d{3}-\d{3}-\d{4}/
let date = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
if let m = "2024-01-15".firstMatch(of: date) { print(m.year) }

import RegexBuilder
let email = Regex { OneOrMore(.word); "@"; OneOrMore(.word); "."; Repeat(2...6) { .word } }
text.replacing(email, with: "[REDACTED]")

// Memory: Prefer structs (stack), COW for large data
struct LargeData {
    private var ref: Ref<[Double]>
    var data: [Double] {
        get { ref.value }
        set { if !isKnownUniquelyReferenced(&ref) { ref = Ref(newValue) } else { ref.value = newValue } }
    }
}

// CPU: reserveCapacity, lazy chains, Set for O(1), final classes
var results: [Item] = []; results.reserveCapacity(1000)
largeArray.lazy.filter { $0.isValid }.map { $0.transform() }.prefix(10)
let idSet = Set(ids); idSet.contains(id)
final class Service { }

// Network: Reuse URLSession, cache, retry with backoff
static let session: URLSession = { let c = URLSessionConfiguration.default; c.timeoutIntervalForRequest = 30; return URLSession(configuration: c) }()