Inventory

// Inventory: the stock list of a small shop, kept as structs in a `Vector`, and a day of orders
// applied to it, some of which cannot be carried out.
//
// Every change to the stock is a fallible function, and each way it can be refused is a case of
// `StockError` carrying the details: which item is unknown, how many were wanted and how many
// were there. A refused order changes nothing, so the stock is never left half-updated.
//
// A delivery of something new adds an item to the vector, and adding can run out of memory. That
// is a `CollectionError`, a different kind of failure altogether, so `Apply` fails with the sum
// `StockError | CollectionError` and both kinds pass through its `?` unchanged.
import Allocator::{ Allocator, SystemAllocator };
import Collections::{ CollectionError, EqualsSlice, Vector };
import Io::PrintLine;

struct StockItem {
    name: char8[..];
    count: int32;
}

variant StockError {
    UnknownItem(char8[..]),
    BadAmount(int32),
    NotEnough { name: char8[..]; have: int32; wanted: int32; },
    StillInStock { name: char8[..]; count: int32; }
}

variant Order {
    Sell { name: char8[..]; amount: int32; },
    Deliver { name: char8[..]; amount: int32; },
    Retire(char8[..])
}

// Where the item sits in the vector, or `none` if the shop has never stocked it. Names are
// compared with `EqualsSlice`: `==` on two slices is refused, because it would ask whether they
// are the same view rather than whether they hold the same text.
func Find(stock: &Vector<StockItem>, name: char8[..]) -> uint? {
    let items = stock.AsSlice();
    for i in 0..items.length {
        if EqualsSlice(items[i].name, name) {
            return i;
        }
    }
    return none;
}

func Sell(stock: &var Vector<StockItem>, name: char8[..], amount: int32) -> ! StockError {
    if amount <= 0 {
        fail StockError::BadAmount(amount);
    }
    // An absent position becomes a failure on the spot.
    let index = Find(stock, name) ?? fail StockError::UnknownItem(name);
    var items = stock.AsMutableSlice();
    if items[index].count < amount {
        fail StockError::NotEnough { name: name, have: items[index].count, wanted: amount };
    }
    items[index].count -= amount;
}

func Deliver(stock: &var Vector<StockItem>, name: char8[..], amount: int32)
    -> ! (StockError | CollectionError) {
    if amount <= 0 {
        fail StockError::BadAmount(amount);
    }
    match Find(stock, name) {
        index? => {
            var items = stock.AsMutableSlice();
            items[index].count += amount;
        },
        none => stock.Push(StockItem { name: name, count: amount })?
    }
}

// An item leaves the list only once it has sold out.
func Retire(stock: &var Vector<StockItem>, name: char8[..]) -> ! StockError {
    let index = Find(stock, name) ?? fail StockError::UnknownItem(name);
    let count = stock.AsSlice()[index].count;
    if count > 0 {
        fail StockError::StillInStock { name: name, count: count };
    }
    // `RemoveAt` hands back the item it took out, as an optional; it is not needed here.
    stock.RemoveAt(index);
}

func Apply(stock: &var Vector<StockItem>, order: Order) -> ! (StockError | CollectionError) {
    match order {
        .Sell { name, amount } => {
            PrintLine("sell {} {}", amount, name);
            Sell(stock, name, amount)?;
        },
        .Deliver { name, amount } => {
            PrintLine("deliver {} {}", amount, name);
            Deliver(stock, name, amount)?;
        },
        .Retire(name) => {
            PrintLine("retire {}", name);
            Retire(stock, name)?;
        }
    }
}

func Explain(error: StockError) {
    match error {
        .UnknownItem(name) => PrintLine("    refused: no such item as {}", name),
        .BadAmount(amount) => PrintLine("    refused: {} is not an amount", amount),
        .NotEnough { name, have, wanted } =>
            PrintLine("    refused: wanted {} {}, only {} left", wanted, name, have),
        .StillInStock { name, count } =>
            PrintLine("    refused: {} {} still on the shelf", count, name)
    }
}

func PrintStock(stock: &Vector<StockItem>) {
    for item in stock {
        PrintLine("    {:10} {:3}", item.name, item.count);
    }
}

func Main() -> ! CollectionError {
    var system = SystemAllocator();
    let allocator: Allocator = system;

    var stock = Vector<StockItem>(allocator);
    stock.Push(StockItem { name: "apples", count: 12 })?;
    stock.Push(StockItem { name: "bread", count: 3 })?;
    stock.Push(StockItem { name: "candles", count: 0 })?;
    stock.Push(StockItem { name: "milk", count: 6 })?;
    PrintLine("opening stock");
    PrintStock(stock);

    let orders = [
        Order::Sell { name: "apples", amount: 5 },
        Order::Sell { name: "bread", amount: 4 },
        Order::Sell { name: "honey", amount: 1 },
        Order::Deliver { name: "bread", amount: 10 },
        Order::Sell { name: "bread", amount: 4 },
        Order::Deliver { name: "honey", amount: 2 },
        Order::Sell { name: "milk", amount: -2 },
        Order::Retire("milk"),
        Order::Retire("candles"),
        Order::Sell { name: "milk", amount: 6 }
    ];
    var refused = 0;
    for order in orders {
        match Apply(stock, order) {
            .Success(()) => PrintLine("    done"),
            .Failure(error: StockError) => {
                Explain(error);
                refused += 1;
            },
            // Running out of memory is no fault of the order, so it ends the day.
            .Failure(error: CollectionError) => fail error
        }
    }

    PrintLine("closing stock, after {} refused orders", refused);
    PrintStock(stock);
}