Inventory Tracker

Overview

An inventory system needs more than a raw stock count — it needs a small, fixed set of *meaningful categories* a product can fall into: fully stocked, running low, or completely out. You could represent that with an enum class, and that would work for the labels alone, but a sealed class lets each state carry its own extra data, and it earns something an enum cannot give you: when you when-match over a sealed class without an else branch, the Kotlin compiler checks at compile time that every possible subtype has been handled, and refuses to compile if you add a new state later and forget to handle it somewhere.

By the end of this tutorial you will have a console application built around a Product data class, Kotlin's collection operations (filter, sortedBy, map) to slice and order the inventory, and a sealed class StockStatus with InStock, LowStock, and OutOfStock variants classified by an exhaustive when expression. That combination — immutable data classes plus a sealed hierarchy for "one of a few known states" — is one of the most distinctly Kotlin ways to model a domain, and it generalizes to almost any system with a small number of well-defined states: order status, connection state, or, as here, stock level.

Prerequisites

Project Structure

The whole program lives in a single file, InventoryTracker.kt, containing Product, the StockStatus sealed class hierarchy, a statusFor() classification function, an InventoryTracker class that owns the product list, and fun main(). Product never knows about StockStatus — the classification logic lives entirely in statusFor(), kept separate from the data it classifies, the same separation of "data" from "behavior over that data" used in the grading project's gradeFor(). InventoryTracker is the layer that owns the List<Product> and turns raw products into a rendered report using both statusFor() and the collection operations from Step 4.

Step 1: Define the Product Data Class

Every field is a val, making Product immutable — once created, a product's quantity never changes in place; instead, restocking a product later means producing a *new* Product with copy(quantity = newQuantity), which the generated copy() function makes trivial. Immutability here is deliberate: a Product inside a List<Product> can never be silently mutated by code elsewhere that happens to hold the same reference, which removes a whole category of bugs by construction.

// All vals: Product is immutable by design. Restocking never mutates a
// Product in place — it produces a new one via copy(quantity = ...), so no
// code holding a reference to a Product can have it change out from under it.
data class Product(
    val id: Int,             // Unique identifier for this product
    val name: String,        // Product name
    val quantity: Int,       // Units currently on hand
    val reorderLevel: Int    // Threshold below which the product counts as "low stock"
)

Step 2: Model Stock Status With a Sealed Class

sealed class StockStatus declares a closed hierarchy: every subtype of StockStatus must be defined in this same file, so the compiler knows the *complete* list of possibilities and can verify a when over them is exhaustive. InStock and LowStock are declared as data class subtypes because each needs to carry its own quantity (and LowStock also a reorderLevel), while OutOfStock carries no extra data at all, so it is declared as a Kotlin object — a singleton, since every out-of-stock product needs no distinguishing state beyond the fact that it is out of stock.

// sealed class = a closed set of subtypes, all declared right here. The
// compiler uses that closed set to verify a when-over-StockStatus handles
// every case — critical for catching a missed branch if a new state is added.
sealed class StockStatus {
    data class InStock(val quantity: Int) : StockStatus()                        // Carries its own quantity for display
    data class LowStock(val quantity: Int, val reorderLevel: Int) : StockStatus()  // Carries both figures for the report
    object OutOfStock : StockStatus()                                             // No extra data needed: a singleton
}

Step 3: Classify a Product With an Exhaustive when

statusFor() is a single-expression function whose body is a when with no else branch at all — and it still compiles, because the compiler can see StockStatus is sealed and can prove InStock, LowStock, and OutOfStock are the only three possibilities. If a fourth variant, say Discontinued, were ever added to StockStatus in Step 2, this when would immediately fail to compile until a matching branch were added here too — that is the real payoff of sealed class over a plain enum.

fun statusFor(product: Product): StockStatus = when {
    product.quantity <= 0 -> StockStatus.OutOfStock
    product.quantity <= product.reorderLevel -> StockStatus.LowStock(product.quantity, product.reorderLevel)
    else -> StockStatus.InStock(product.quantity)
    // No "else" is required here for exhaustiveness over StockStatus's subtypes — this when { } uses boolean
    // conditions instead of matching on a subject, so it needs its own else as a boolean fallback, which is
    // different from an exhaustiveness check; a when(status) { is InStock -> ...; is LowStock -> ...; ... }
    // matching directly on a StockStatus value is the one the compiler checks for exhaustiveness, as used next.
}

Step 4: Filter and Sort the Inventory

lowStockItems() uses filter { } with a lambda predicate to keep only products whose computed StockStatus is not InStock, using the is operator to check a sealed subtype the same way instanceof would in Java. sortedByQuantity() uses sortedBy { it.quantity }, which returns a *new* list in ascending order without mutating the original — consistent with Product being immutable, sorting never has a reason to touch the source list at all.

fun lowStockItems(products: List<Product>): List<Product> {
    // filter{} keeps only elements where the lambda returns true; "is" checks a sealed subtype like Java's instanceof
    return products.filter { statusFor(it) !is StockStatus.InStock }
}

fun sortedByQuantity(products: List<Product>): List<Product> {
    return products.sortedBy { it.quantity }   // Returns a new List sorted ascending; the original list is untouched
}

Step 5: Build the InventoryTracker and Report

InventoryTracker owns the List<Product> and produces a formatted report line for every product, using a second when — this time matching directly on the StockStatus value itself with is InStock ->/is LowStock ->/OutOfStock -> branches, which is the version the compiler genuinely checks for exhaustiveness. Each branch destructures the sealed subtype's own properties (status.quantity, status.reorderLevel) directly, which only type-checks because the compiler has smart-cast status to that specific subtype inside its branch.

class InventoryTracker(private val products: List<Product>) {

    fun report(): List<String> {
        return products.map { product ->              // map{} transforms each Product into one report line
            val status = statusFor(product)
            val message = when (status) {                // Matches directly on StockStatus: exhaustive, no else needed
                is StockStatus.InStock -> "In stock (${status.quantity} units)"
                is StockStatus.LowStock -> "Low stock! ${status.quantity} left (reorder at ${status.reorderLevel})"
                StockStatus.OutOfStock -> "Out of stock"   // object subtype: matched by name, no "is" needed
            }
            "${product.name}: $message"
        }
    }

    fun lowStock(): List<Product> = lowStockItems(products)   // Reuses Step 4's standalone function
}

Step 6: Build the Program Entry Point

main() builds a small hard-coded catalog spanning all three stock states, wraps it in an InventoryTracker, and prints both the full report from Step 5 and the low-stock-only list from Step 4, sorted by quantity ascending so the most urgent items appear first.

fun main() {
    val catalog = listOf(
        Product(1, "USB Cable", 40, 10),
        Product(2, "Wireless Mouse", 3, 5),
        Product(3, "Keyboard", 0, 5),
        Product(4, "Monitor Stand", 12, 4),
    )
    val tracker = InventoryTracker(catalog)

    println("===== INVENTORY REPORT =====")
    for (line in tracker.report()) {
        println(line)
    }

    println("\n===== LOW STOCK (sorted, most urgent first) =====")
    for (product in sortedByQuantity(tracker.lowStock())) {
        println("${product.name}: ${product.quantity} left")
    }
}

Complete Code

Here is the full program with every declaration assembled in the correct order, ready to save as InventoryTracker.kt and run with kotlinc InventoryTracker.kt -include-runtime -d inventory.jar && java -jar inventory.jar.

data class Product(
    val id: Int,
    val name: String,
    val quantity: Int,
    val reorderLevel: Int
)

sealed class StockStatus {
    data class InStock(val quantity: Int) : StockStatus()
    data class LowStock(val quantity: Int, val reorderLevel: Int) : StockStatus()
    object OutOfStock : StockStatus()
}

fun statusFor(product: Product): StockStatus = when {
    product.quantity <= 0 -> StockStatus.OutOfStock
    product.quantity <= product.reorderLevel -> StockStatus.LowStock(product.quantity, product.reorderLevel)
    else -> StockStatus.InStock(product.quantity)
}

fun lowStockItems(products: List<Product>): List<Product> {
    return products.filter { statusFor(it) !is StockStatus.InStock }
}

fun sortedByQuantity(products: List<Product>): List<Product> {
    return products.sortedBy { it.quantity }
}

class InventoryTracker(private val products: List<Product>) {

    fun report(): List<String> {
        return products.map { product ->
            val status = statusFor(product)
            val message = when (status) {
                is StockStatus.InStock -> "In stock (${status.quantity} units)"
                is StockStatus.LowStock -> "Low stock! ${status.quantity} left (reorder at ${status.reorderLevel})"
                StockStatus.OutOfStock -> "Out of stock"
            }
            "${product.name}: $message"
        }
    }

    fun lowStock(): List<Product> = lowStockItems(products)
}

fun main() {
    val catalog = listOf(
        Product(1, "USB Cable", 40, 10),
        Product(2, "Wireless Mouse", 3, 5),
        Product(3, "Keyboard", 0, 5),
        Product(4, "Monitor Stand", 12, 4),
    )
    val tracker = InventoryTracker(catalog)

    println("===== INVENTORY REPORT =====")
    for (line in tracker.report()) {
        println(line)
    }

    println("\n===== LOW STOCK (sorted, most urgent first) =====")
    for (product in sortedByQuantity(tracker.lowStock())) {
        println("${product.name}: ${product.quantity} left")
    }
}

Sample Run

Extend This Project

Summary

You built an inventory tracker where Product stays a small, immutable data class, and StockStatus uses a sealed class to make "in stock, low stock, or out of stock" a closed set the compiler actively enforces — try adding a fourth state and every exhaustive when in the file will refuse to compile until you handle it. Combined with filter, sortedBy, and map, this is the same shape — a sealed hierarchy for a domain's finite states, paired with collection operations for querying it — that you will reach for anywhere a Kotlin program needs to model "one of a few known outcomes" safely.