Inventory Tracker

Model products with structs, filter and sort stock levels, and report low-stock items using protocols.

StructsProtocolsCollections

Overview

An inventory tracker is where Swift protocols earn their keep. Every `Product` needs to answer two questions the same way — "am I low on stock?" and "what does my current stock line look like?" — and a `protocol` is how Swift describes that shared contract without forcing every conforming type into a rigid class hierarchy. `Product` conforms to `StockReportable` simply by implementing the two computed properties the protocol requires; any future type that needs the same low-stock behavior could conform to the exact same protocol and slot into the exact same reporting code with zero changes to that code.

By the end of this tutorial you will have a console application built around a `Product` struct and a `StockReportable` protocol it conforms to, plus an `InventoryManager` struct that owns the catalog and exposes restock, sell, and low-stock-report operations. You will also lean on Swift's collection operations — `filter`, `sorted(by:)`, and `first(where:)` — to search and rank products instead of writing manual index-tracking loops.

What You'll Build

A `StockReportable` protocol describing `isLowStock` and `stockSummary`.
A `Product` struct with `sku`, `name`, `quantity`, and `reorderThreshold` fields that conforms to it.
An `InventoryManager` struct owning an `[Product]` catalog.
`restock(sku:amount:)` and `sell(sku:amount:)` methods that validate before ever changing quantity.
A `lowStockReport()` built with `filter`, typed against the protocol rather than the concrete struct.
A `sortedByQuantity()` report using `sorted(by:)` to surface the most urgent items first.

Prerequisites

Structs — stored properties, computed properties, and `mutating` methods.
Protocols — declaring a `protocol` and having a `struct` conform to it.
Collections — `Array`, `filter`, `sorted(by:)`, and `first(where:)`/`firstIndex(where:)`.
Optionals — `guard let` for a lookup that might not find a match.
Closures — the trailing-closure syntax used by `filter`, `sorted`, and `first(where:)`.

Project Structure

The program lives in a single file, `main.swift`. `StockReportable` is declared before `Product` since `Product` needs the protocol to already exist in order to conform to it. `InventoryManager` owns the actual `[Product]` array and is the only type that ever mutates it — every menu action goes through a method on `InventoryManager`, the same ownership pattern used by `TaskManager` and `StudentManager` in the other Swift projects in this course, just applied here to stock levels instead of tasks or grades.

Step 1: Define the Product Struct and StockReportable Protocol

`StockReportable` describes "anything that can report on its own stock level" as two read-only computed requirements. Declaring it as a separate protocol, rather than just writing these two properties directly on `Product`, means any future type — a bundled multi-pack, a backordered item — could conform to the same protocol and be reported on by the exact same low-stock logic below, without that reporting code needing to know those other types exist.

// A protocol describing "anything that can report on its own stock level."
// Declaring it separately from Product means any future type could conform
// to the same protocol and be reported on with the exact same low-stock
// logic below, without that logic needing to know those types exist.
protocol StockReportable {
    var isLowStock: Bool { get }      // true once quantity has fallen to or below its reorder threshold
    var stockSummary: String { get }  // A single human-readable line describing current stock
}

// Product conforms to StockReportable by implementing both computed
// properties the protocol requires — Swift checks at compile time that every
// requirement is actually satisfied, or the struct simply won't compile.
struct Product: StockReportable {
    let sku: String              // Stock-keeping unit; unique identifier, never changes after creation
    let name: String
    var quantity: Int            // var: quantity changes constantly as stock is sold or restocked
    let reorderThreshold: Int    // At or below this quantity, the product counts as low stock

    // Computed, not stored — isLowStock is always derived from quantity and
    // reorderThreshold, so there is no separate Bool that could ever drift
    // out of sync with the numbers it's supposed to reflect.
    var isLowStock: Bool {
        quantity <= reorderThreshold
    }

    var stockSummary: String {
        let status = isLowStock ? " — LOW STOCK" : ""
        return "\(name) (\(sku)): \(quantity) in stock\(status)"
    }
}

Step 2: Build the InventoryManager and Add Products

`findProduct(sku:)` returns `Product?`, not `Product`, because the sku the caller asks for might not exist in the catalog at all — `first(where:)` already returns an Optional for exactly this reason, so the method just forwards that Optional straight to its own caller instead of forcing an unwrap here.

struct InventoryManager {
    private var products: [Product] = []   // Every product currently tracked

    mutating func addProduct(_ product: Product) {
        products.append(product)
    }

    // Returns Product?, not Product, because the sku the caller asks for
    // might not exist in the catalog at all.
    func findProduct(sku: String) -> Product? {
        products.first { $0.sku == sku }
    }
}

Step 3: Restock Products

`restock(sku:amount:)` chains two conditions inside one `guard`: the sku must actually exist in the catalog, found through `firstIndex(where:)`, and `amount` must be positive — a restock of zero or a negative amount is rejected before `products[index].quantity` is ever touched.

// `mutating` because this writes to one Product's quantity inside `products`.
mutating func restock(sku: String, amount: Int) -> Bool {
    guard let index = products.firstIndex(where: { $0.sku == sku }), amount > 0 else {
        return false   // Either the sku doesn't exist, or the caller passed a non-positive amount
    }
    products[index].quantity += amount
    return true
}

Step 4: Sell Products

`sell(sku:amount:)` adds a third condition to the same `guard` pattern from Step 3: `products[index].quantity >= amount`, which rejects selling more units than are actually in stock. All three checks live in one `guard`, so a failure for any reason — unknown sku, non-positive amount, or insufficient stock — takes the exact same early-exit path, keeping the "happy path" below it free of nested `if` statements.

mutating func sell(sku: String, amount: Int) -> Bool {
    guard let index = products.firstIndex(where: { $0.sku == sku }),
          amount > 0,
          products[index].quantity >= amount else {
        return false   // Rejects an unknown sku, a non-positive amount, or selling more than is in stock
    }
    products[index].quantity -= amount
    return true
}

Step 5: Filter and Sort for a Low-Stock Report

`lowStockReport()` is typed to return `[StockReportable]`, not `[Product]`, on purpose — this function only actually needs the two properties the protocol guarantees, so typing its result against the protocol rather than the concrete struct means it would keep working unchanged for any future type that also conforms to `StockReportable`. `sortedByQuantity()` uses `sorted(by:)`, which returns a brand-new array in ascending order without mutating `products` itself, putting the most urgent (lowest-quantity) products first.

// Returns [StockReportable], not [Product] — this function only needs the
// two properties the protocol guarantees, so typing its result against the
// protocol keeps it working unchanged for any future StockReportable type.
func lowStockReport() -> [StockReportable] {
    products.filter { $0.isLowStock }
}

// sorted(by:) returns a new array; ascending order puts the most urgent
// (lowest-quantity) products first without mutating `products` itself.
func sortedByQuantity() -> [Product] {
    products.sorted { $0.quantity < $1.quantity }
}

func listAll() {
    for product in sortedByQuantity() {
        print(product.stockSummary)   // Reuses the same summary the low-stock report uses
    }
}

func printLowStockReport() {
    let lowStock = lowStockReport()
    if lowStock.isEmpty {
        print("No products are currently low on stock.")
        return
    }
    print("\n--- Low Stock Report ---")
    for item in lowStock {
        print(item.stockSummary)   // Calling through the protocol, not the concrete Product type
    }
}

Step 6: Build the Menu Loop

When adding a product, `Int(readLine() ?? "") ?? 0` chains two nil-coalescing operators: the first supplies an empty string if the line can't be read at all, and the second supplies `0` if that string can't be parsed as a number — either way, the menu loop never crashes on bad input, it just falls back to a sensible default.

var manager = InventoryManager()
var running = true

while running {
    print("""

    ===== INVENTORY TRACKER =====
    1. Add Product
    2. List All Products
    3. Restock
    4. Sell
    5. Low Stock Report
    6. Exit
    """)
    print("Enter your choice: ", terminator: "")
    guard let choiceLine = readLine(), let choice = Int(choiceLine) else {
        print("Invalid input, try again.")
        continue
    }

    switch choice {
    case 1:
        print("Enter SKU: ", terminator: "")
        let sku = readLine() ?? ""
        print("Enter product name: ", terminator: "")
        let name = readLine() ?? ""
        print("Enter starting quantity: ", terminator: "")
        let quantity = Int(readLine() ?? "") ?? 0   // Non-numeric input safely becomes a starting quantity of 0
        print("Enter reorder threshold: ", terminator: "")
        let threshold = Int(readLine() ?? "") ?? 0
        manager.addProduct(Product(sku: sku, name: name, quantity: quantity, reorderThreshold: threshold))
        print("Product added.")
    case 2:
        manager.listAll()
    case 3:
        print("Enter SKU to restock: ", terminator: "")
        let sku = readLine() ?? ""
        print("Enter amount: ", terminator: "")
        if let amount = Int(readLine() ?? "") {
            print(manager.restock(sku: sku, amount: amount) ? "Restocked." : "Restock failed.")
        }
    case 4:
        print("Enter SKU to sell: ", terminator: "")
        let sku = readLine() ?? ""
        print("Enter amount: ", terminator: "")
        if let amount = Int(readLine() ?? "") {
            print(manager.sell(sku: sku, amount: amount) ? "Sale recorded." : "Sale failed — check stock level.")
        }
    case 5:
        manager.printLowStockReport()
    case 6:
        print("Goodbye!")
        running = false
    default:
        print("Invalid choice, try again.")
    }
}

Complete Code

Here is the full program assembled in the correct order, ready to save as `main.swift` and run with `swift main.swift`, or paste into a Swift Playground.

protocol StockReportable {
    var isLowStock: Bool { get }
    var stockSummary: String { get }
}

struct Product: StockReportable {
    let sku: String
    let name: String
    var quantity: Int
    let reorderThreshold: Int

    var isLowStock: Bool {
        quantity <= reorderThreshold
    }

    var stockSummary: String {
        let status = isLowStock ? " — LOW STOCK" : ""
        return "\(name) (\(sku)): \(quantity) in stock\(status)"
    }
}

struct InventoryManager {
    private var products: [Product] = []

    mutating func addProduct(_ product: Product) {
        products.append(product)
    }

    func findProduct(sku: String) -> Product? {
        products.first { $0.sku == sku }
    }

    mutating func restock(sku: String, amount: Int) -> Bool {
        guard let index = products.firstIndex(where: { $0.sku == sku }), amount > 0 else {
            return false
        }
        products[index].quantity += amount
        return true
    }

    mutating func sell(sku: String, amount: Int) -> Bool {
        guard let index = products.firstIndex(where: { $0.sku == sku }),
              amount > 0,
              products[index].quantity >= amount else {
            return false
        }
        products[index].quantity -= amount
        return true
    }

    func lowStockReport() -> [StockReportable] {
        products.filter { $0.isLowStock }
    }

    func sortedByQuantity() -> [Product] {
        products.sorted { $0.quantity < $1.quantity }
    }

    func listAll() {
        for product in sortedByQuantity() {
            print(product.stockSummary)
        }
    }

    func printLowStockReport() {
        let lowStock = lowStockReport()
        if lowStock.isEmpty {
            print("No products are currently low on stock.")
            return
        }
        print("\n--- Low Stock Report ---")
        for item in lowStock {
            print(item.stockSummary)
        }
    }
}

var manager = InventoryManager()
var running = true

while running {
    print("""

    ===== INVENTORY TRACKER =====
    1. Add Product
    2. List All Products
    3. Restock
    4. Sell
    5. Low Stock Report
    6. Exit
    """)
    print("Enter your choice: ", terminator: "")
    guard let choiceLine = readLine(), let choice = Int(choiceLine) else {
        print("Invalid input, try again.")
        continue
    }

    switch choice {
    case 1:
        print("Enter SKU: ", terminator: "")
        let sku = readLine() ?? ""
        print("Enter product name: ", terminator: "")
        let name = readLine() ?? ""
        print("Enter starting quantity: ", terminator: "")
        let quantity = Int(readLine() ?? "") ?? 0
        print("Enter reorder threshold: ", terminator: "")
        let threshold = Int(readLine() ?? "") ?? 0
        manager.addProduct(Product(sku: sku, name: name, quantity: quantity, reorderThreshold: threshold))
        print("Product added.")
    case 2:
        manager.listAll()
    case 3:
        print("Enter SKU to restock: ", terminator: "")
        let sku = readLine() ?? ""
        print("Enter amount: ", terminator: "")
        if let amount = Int(readLine() ?? "") {
            print(manager.restock(sku: sku, amount: amount) ? "Restocked." : "Restock failed.")
        }
    case 4:
        print("Enter SKU to sell: ", terminator: "")
        let sku = readLine() ?? ""
        print("Enter amount: ", terminator: "")
        if let amount = Int(readLine() ?? "") {
            print(manager.sell(sku: sku, amount: amount) ? "Sale recorded." : "Sale failed — check stock level.")
        }
    case 5:
        manager.printLowStockReport()
    case 6:
        print("Goodbye!")
        running = false
    default:
        print("Invalid choice, try again.")
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a `Supplier` type and a `reorder(product:)` function that "places an order" automatically once `isLowStock` becomes true.
Track a `priceHistory: [Double]` per product and add an `averagePrice` computed property.
Persist the catalog to a JSON file using `Codable` with `JSONEncoder`/`JSONDecoder`.
Add a `category: String` field and a `report(for category:)` function built with `filter`.
Make `Product` conform to `Comparable` so `products.sorted()` works directly without a custom closure.

Summary

You built an inventory tracker where a `protocol` defined a shared contract — "can report on your own stock level" — that `Product` conforms to, and the low-stock report was written against that protocol instead of the concrete struct. That is the core payoff of protocol-oriented Swift: `lowStockReport()` genuinely does not care whether it is iterating `Product` values or some other `StockReportable` type introduced later, because it only ever calls the two properties the protocol promises. Combined with `filter` and `sorted(by:)` for querying the catalog, that is the same pattern you will reach for anywhere a Swift program needs to report on a collection of things that can each answer the same small set of questions about themselves.