Working with APIs 🌐

import Foundation

// A "model" is a Swift type that mirrors the shape of the JSON.
// Conforming to Codable lets Swift map JSON <-> this struct for free.
struct Post: Codable {
    let id: Int
    let title: String
    let body: String
}

// This is the exact JSON the API would send back (a single post).
let jsonString = """
{
  "id": 1,
  "title": "Hello, Swift",
  "body": "Networking is easier than it looks."
}
"""

// 1. Turn the text into Data (the raw bytes a server returns).
let data = Data(jsonString.utf8)

// 2. JSONDecoder reads the bytes and fills in a Post for you.
//    'Post.self' tells the decoder which type to build.
let post = try JSONDecoder().decode(Post.self, from: data)

// 3. Now it's a normal Swift value — use it like any struct.
print("Post #\(post.id): \(post.title)")   // Post #1: Hello, Swift
print(post.body)                            // Networking is easier than it looks.

Post #1: Hello, Swift
Networking is easier than it looks.

import Foundation

struct Post: Codable {
    let id: Int
    let title: String
    let body: String
}

// A custom error type makes failures readable and easy to 'catch'.
enum APIError: Error {
    case badStatus(Int)
}

// 'async' = this function can pause; 'throws' = it can fail.
// '-> [Post]' = on success it hands back an array of Post.
func fetchPosts() async throws -> [Post] {
    // 'URL(string:)' returns an Optional, so unwrap it safely.
    guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {
        throw APIError.badStatus(0)
    }

    // 'await' suspends here until the bytes arrive — no callbacks, no freezing.
    let (data, response) = try await URLSession.shared.data(from: url)

    // URLSession does NOT throw on 404/500, so check the status yourself.
    guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
        throw APIError.badStatus((response as? HTTPURLResponse)?.statusCode ?? -1)
    }

    // Decode the JSON array straight into [Post].
    return try JSONDecoder().decode([Post].self, from: data)
}

// Call it from an async context and handle errors with do/catch.
Task {
    do {
        let posts = try await fetchPosts()
        print("Fetched \(posts.count) posts")     // Fetched 100 posts
        print("First: \(posts[0].title)")          // First: sunt aut facere ...
    } catch {
        print("Request failed: \(error)")
    }
}

Fetched 100 posts
First: sunt aut facere repellat provident occaecati

import Foundation

// 🎯 YOUR TURN — fill in each ___ then run it (try it on SwiftFiddle).

// The API sends this JSON for one user:
let jsonString = """
{ "id": 7, "name": "Ada Lovelace", "isActive": true }
"""

// 1) Make the model match the JSON. It must conform to Codable
//    and have a property for each key, with the matching type.
struct User: ___ {              // 👉 the protocol that enables JSON mapping
    let id: Int
    let name: String
    let isActive: ___           // 👉 the Swift type for true/false
}

let data = Data(jsonString.utf8)

// 2) Decode the bytes into a User. Pass the TYPE, not an instance.
let user = try JSONDecoder().decode(___, from: data)   // 👉 User.self

print("\(user.name) — active: \(user.isActive)")

// ✅ Expected output:
//    Ada Lovelace — active: true

Ada Lovelace — active: true

import Foundation

struct Quote: Codable { let text: String }

func fetchQuote() ___ throws -> Quote {     // 👉 the keyword that allows 'await'
    guard let url = URL(string: "https://example.com/quote") else {
        throw URLError(.badURL)
    }

    // 1) Suspend until the data arrives. URLSession.shared.data(from:)
    //    is an async throwing call, so it needs TWO keywords here.
    let (data, _) = try ___ URLSession.shared.data(from: url)   // 👉 the suspend keyword

    // 2) Decode the JSON into a Quote.
    return try JSONDecoder().decode(Quote.self, from: data)
}

Task {
    do {
        let quote = try await fetchQuote()
        print(quote.text)
    } catch {
        // 3) Print the error so a failed request never crashes the app.
        print("Could not load quote: \(___)")   // 👉 the value caught by 'catch'
    }
}

// ✅ Expected (on success): the quote text prints.
//    On failure: "Could not load quote: ..." prints instead of crashing.

import SwiftUI

struct Post: Codable, Identifiable {
    let id: Int
    let title: String
}

struct PostListView: View {
    // @State holds data that, when changed, redraws the view.
    @State private var posts: [Post] = []
    @State private var errorMessage: String?

    var body: some View {
        List {
            if let errorMessage {
                Text(errorMessage).foregroundStyle(.red)
            }
            ForEach(posts) { post in
                Text(post.title)
            }
        }
        // '.task' runs async code when the view appears and
        // auto-cancels it if the view disappears — perfect for loading.
        .task {
            do {
                posts = try await fetchPosts()
            } catch {
                // UI updates from .task are already on the main actor — safe here.
                errorMessage = "Failed to load: \(error.localizedDescription)"
            }
        }
    }
}