EasySwift iOS🍏

// Используя joined
let languages = ["Swift", "Kotlin", "Rust"]

let joinedLanguages = languages.dropLast().joined(separator: ", ")
    + (languages.count > 1 ? " and " : "")
    + (languages.last ?? "")
// "Swift, Kotlin and Rust"

// Используя ListFormatter

let listFormatter = ListFormatter()
// "Swift, Kotlin, and Rust"
listFormatter.string(from: ["Swift", "Kotlin", "Rust"])

let listFormatter = ListFormatter()
listFormatter.locale = Locale(identifier: "es-ES")
// "Swift, Kotlin y Rust"
listFormatter.string(from: ["Swift", "Kotlin", "Rust"])

func testFibonacciSequenceThrowsError() async throws {
    do {
        let _ = try await fibonacciSequence(count: -1)
        XCTFail("Expected an error for negative count, but no error was thrown")
    } catch FibonacciError.invalidCount {
        // Success! The expected error was thrown.
    } catch {
        XCTFail("Unexpected error thrown: \(error)")
    }
}

let button = UIButton(frame: buttonFrame)
view.addSubview(button)
button.setTitle("This is a button", for: .normal)
button.addTarget(
  self,
  action: #selector(handleTap), 
  for: .touchUpInside
)
  
@objc func handleTap() async {
  Task {
    debugPrint("handle Tap")
  }
}

struct SingleUseTicket: ~Copyable {
    let ticketID: Int
    
    consuming func invalidate() {
        print("Ticket \(ticketID) invalidated.")
        
        // cleanup logic
        
        discard self
    }
    
    deinit {
        print("Ticket deinitialized.")
        
        // cleanup logic
    }
}

func exampleFunc() async {
  let isNotSendable = MyClass()

  // Value of non-Sendable type ... accessed after being transferred; 
  // later accesses could race
  Task {
    isNotSendable.count += 1
  }

  // Access can happen concurrently
  print(isNotSendable.count)
}

// This struct is not sendable
struct Movie {
    let formatterCache = FormatterCache() // This is class
    let releaseDate = Date()
    var formattedReleaseDate: String {
        let formatter = formatterCache.formatter(for: "YYYY")
        return formatter.string(from: releaseDate)
    }
}

// This struct is sendable
struct Movie {
    var formattedReleaseDate = "2022"
}

private extension HTTPClient: URLSessionDelegate {
    /// Handles server authentication challenges for Certificate Pinning.
    func urlSession(
        _ session: URLSession,
        didReceive challenge: URLAuthenticationChallenge,
        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
    ) {
        // We will write our pinning business logic here.
    }
}

protocol Registrable {
    static func register()
}

extension Registrable {
    static func register() {
        print("Registering \(Self.self)")
    }
}

class Service: Registrable {}

// Prints `Registering Service`
Service.register()

let closedRange = Int.min...3
let partialRange = ...3

let numbers = [10, 20, 30, 40, 50, 60, 70]

print(numbers[closedRange]) // 💣💣💣 ERROR: Negative Array index is out of range

let numbers = [10, 20, 30, 40, 50, 60, 70]

print(numbers[partialRange]) // from the first index in the sequence, all the way to index: 3 
// Prints "[10, 20, 30, 40]"

class ViewController: UIViewController {
    ...

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        self.startAnimating()
    }

    private func startAnimating() {
        let animation = SwiftUI.Animation
            .linear(duration: 1.3)
            .repeatForever()
        
        UIView.animate(animation) { [weak self] in
            self?.animatingView?.transform = .init(scaleX: 2, y: 2)
        }
    }
}

func fetchImage(for url: URL, completion: @escaping (Result<UIImage, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let data, let image = UIImage(data: data) else {
            DispatchQueue.main.async {
                completion(.failure(ImageFetchingError.imageDecodingFailed))
            }
            return
        }

        DispatchQueue.main.async {
            completion(.success(image))
        }
    }.resume()
}

@MainActor
func fetchImage(for url: URL) async throws -> UIImage {
    let (data, _) = try await URLSession.shared.data(from: url)
    guard let image = UIImage(data: data) else {
        throw ImageFetchingError.imageDecodingFailed
    }
    return image
}

var urlComponents = URLComponents(string: "https://httpbin.org/get")!

/// Define the parameters.
let parameters: [String: String] = [
    "name": "Antoine van der Lee",
    "age": "33"
]

/// Add the query parameters to the URL.
urlComponents.queryItems = parameters.map { key, value in
    URLQueryItem(name: key, value: value)
}

/// Ensure we have a valid URL and throw a URLError if it fails.
guard let url = urlComponents.url else {
    throw URLError(.badURL)
}

/// Use URLSession to fetch the data asynchronously.
let (data, response) = try await URLSession.shared.data(from: url)

func completeTodo(
        request: ServerRequest<Todos_TodoID>,
        context: ServerContext
    ) async throws -> ServerResponse<Todos_Todo> {
        guard
            var todo = todos.first(where: { $0.todoID == request.message.todoID })
        else {
            return .init(
                error: RPCError.init(
                    code: .notFound,
                    message: "Todo not found."
                )
            )
        }
        todo.completed = true
        todos = todos.filter { $0.todoID != request.message.todoID }
        todos.append(todo)
        return .init(message: todo)
    }

import NaturalLanguage

func getSemanticDistance(for word: String, in language: NLLanguage) {
  
    // 1. Create the embedding for the language the word belongs to
    if let embedding = NLEmbedding.wordEmbedding(for: language) {
        
        // 2. Find the neighbors for the word
        embedding.enumerateNeighbors(for: word, maximumCount: 10) { neighbor, distance in
            
            // 3. Acces the neighbor distance from the word
            print("\(neighbor): \(distance)")
            
            return true
        }
    }
}

class Foo {
    let a: UInt8
    let b: UInt16
}
MemoryLayout<Foo>.size // 8
MemoryLayout<Foo>.alignment // 8
MemoryLayout<Foo>.stride // 8

json[0]?["name"]?["first"]?.stringValue

// заменится на 

json[0]?.name?.first?.stringValue

// Повысить восприятие кода
typealias StringDictionary<T> = Dictionary<String, T>

// Упростить сигнатуры сложных типов и кортежей
typealias CompletionHandler = (Result<String, Error>) -> Void
typealias GridPoint = (x: Int, y: Int)

// Указать ограничения
typealias StringArrayDictionary = Dictionary<String, [String]>

extension ISO8601DateFormatter {
  func microsecondsDate(from dateString: String) -> Date? {
    guard let millisecondsDate = date(from: dateString) else { return nil }
    guard let fractionIndex = dateString.lastIndex(of: ".") else { return millisecondsDate }
    guard let tzIndex = dateString.lastIndex(of: "Z") else { return millisecondsDate }
    guard let startIndex = dateString.index(fractionIndex, offsetBy: 4, limitedBy: tzIndex) else { return millisecondsDate }
    // Pad the missing zeros at the end and cut off nanoseconds
    let microsecondsString = dateString[startIndex..<tzIndex].padding(toLength: 3, withPad: "0", startingAt: 0)
    guard let microseconds = TimeInterval(microsecondsString) else { return millisecondsDate }
    return Date(timeIntervalSince1970: millisecondsDate.timeIntervalSince1970 + microseconds / 1_000_000.0)
  }
}

extension Task {
  @discardableResult
  init<T>(
    priority: TaskPriority? = nil,
    operation: @escaping () async throws -> T,
    queue: DispatchQueue = .main,
    completion: @escaping (Result<T, Failure>) -> Void
  ) where Success == Void, Failure == any Error {
    self.init(priority: priority) {
      do {
        let value = try await operation()
        queue.async {
          completion(.success(value))
        }
      } catch {
        queue.async {
          completion(.failure(error))
        }
      }
    }
  }
}

Text("She will receive ^[\(count) games](inflect: true).")