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
}

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)
        }
    }
}

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]"

protocol Registrable {
    static func register()
}

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

class Service: Registrable {}

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

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.
    }
}

// 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"
}

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)
}

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