Data, State, Logic and Computation

package main

import (
	"fmt"
	"slices"
	"strings"
)

// Data: facts the business keeps. They change rarely, and not because of this user.
var prices = map[string]int{"tea": 20, "cake": 50}

const maxPerItem = 5 // logic: a rule about what is allowed

// State: this user's cart right now. Every request may change it.
type line struct {
	item string
	qty  int
}

var (
	cart        []line
	storedTotal int // a second copy of the total, kept up to date by hand
)

// Computation: derive the total from the state and the data, every time it's needed.
func computedTotal() int {
	total := 0
	for _, l := range cart {
		total += l.qty * prices[l.item]
	}
	return total
}

// add applies the logic, then changes the state (and tries to keep storedTotal in step).
// A negative qty removes items.
func add(item string, qty int) string {
	i := slices.IndexFunc(cart, func(l line) bool { return l.item == item })
	have := 0
	if i >= 0 {
		have = cart[i].qty
	}
	if have+qty > maxPerItem {
		return fmt.Sprintf("refused: at most %d per item", maxPerItem)
	}
	switch {
	case i < 0:
		cart = append(cart, line{item, qty})
	case have+qty == 0:
		cart = slices.Delete(cart, i, i+1)
	default:
		cart[i].qty += qty
	}
	storedTotal += qty * prices[item]
	return ""
}

func show(step, note string) {
	parts := []string{}
	for _, l := range cart {
		parts = append(parts, fmt.Sprintf("%s x%d", l.item, l.qty))
	}
	row := fmt.Sprintf("%-22s %-15s %6d %9d", step, strings.Join(parts, ", "), storedTotal, computedTotal())
	if note != "" {
		row += "  " + note
	}
	fmt.Println(row)
}

func main() {
	fmt.Printf("%-22s %-15s %6s %9s\n", "step", "cart", "stored", "computed")
	show("add 2 tea", add("tea", 2))
	show("add 1 cake", add("cake", 1))
	prices["tea"] = 25 // the shop changes a price: data changes, the cart doesn't
	show("tea price 20 -> 25", "")
	show("remove 1 tea", add("tea", -1))
	show("add 9 cake", add("cake", 9))
	if storedTotal != computedTotal() {
		fmt.Printf("the stored total is off by %d taka\n", computedTotal()-storedTotal)
	}
}

// Data: facts the business keeps. They change rarely, and not because of this user.
const prices = { tea: 20, cake: 50 };

const MAX_PER_ITEM = 5; // logic: a rule about what is allowed

// State: this user's cart right now. Every request may change it.
let cart = []; // [{ item, qty }], in the order items were added
let storedTotal = 0; // a second copy of the total, kept up to date by hand

// Computation: derive the total from the state and the data, every time it's needed.
const computedTotal = () => cart.reduce((sum, l) => sum + l.qty * prices[l.item], 0);

// add applies the logic, then changes the state (and tries to keep storedTotal in step).
// A negative qty removes items.
function add(item, qty) {
  const line = cart.find((l) => l.item === item);
  const have = line?.qty ?? 0;
  if (have + qty > MAX_PER_ITEM) return `refused: at most ${MAX_PER_ITEM} per item`;
  if (!line) cart.push({ item, qty });
  else if (have + qty === 0) cart = cart.filter((l) => l !== line);
  else line.qty += qty;
  storedTotal += qty * prices[item];
  return "";
}

function show(step, note) {
  const items = cart.map((l) => `${l.item} x${l.qty}`).join(", ");
  let row = `${step.padEnd(22)} ${items.padEnd(15)} ${String(storedTotal).padStart(6)} ${String(computedTotal()).padStart(9)}`;
  if (note) row += `  ${note}`;
  console.log(row);
}

console.log(`${"step".padEnd(22)} ${"cart".padEnd(15)} ${"stored".padStart(6)} ${"computed".padStart(9)}`);
show("add 2 tea", add("tea", 2));
show("add 1 cake", add("cake", 1));
prices.tea = 25; // the shop changes a price: data changes, the cart doesn't
show("tea price 20 -> 25", "");
show("remove 1 tea", add("tea", -1));
show("add 9 cake", add("cake", 9));
if (storedTotal !== computedTotal()) {
  console.log(`the stored total is off by ${computedTotal() - storedTotal} taka`);
}

use std::collections::HashMap;

const MAX_PER_ITEM: i32 = 5; // logic: a rule about what is allowed

struct Shop {
    // Data: facts the business keeps. They change rarely, and not because of this user.
    prices: HashMap<&'static str, i32>,
    // State: this user's cart right now. Every request may change it.
    cart: Vec<(&'static str, i32)>,
    stored_total: i32, // a second copy of the total, kept up to date by hand
}

impl Shop {
    // Computation: derive the total from the state and the data, every time it's needed.
    fn computed_total(&self) -> i32 {
        self.cart.iter().map(|(item, qty)| qty * self.prices[item]).sum()
    }

    // add applies the logic, then changes the state (and tries to keep stored_total in step).
    // A negative qty removes items.
    fn add(&mut self, item: &'static str, qty: i32) -> String {
        let i = self.cart.iter().position(|(it, _)| *it == item);
        let have = i.map_or(0, |i| self.cart[i].1);
        if have + qty > MAX_PER_ITEM {
            return format!("refused: at most {MAX_PER_ITEM} per item");
        }
        match i {
            None => self.cart.push((item, qty)),
            Some(i) if have + qty == 0 => {
                self.cart.remove(i);
            }
            Some(i) => self.cart[i].1 += qty,
        }
        self.stored_total += qty * self.prices[item];
        String::new()
    }

    fn show(&self, step: &str, note: &str) {
        let items: Vec<String> = self.cart.iter().map(|(item, qty)| format!("{item} x{qty}")).collect();
        let mut row = format!("{:<22} {:<15} {:>6} {:>9}", step, items.join(", "), self.stored_total, self.computed_total());
        if !note.is_empty() {
            row += &format!("  {note}");
        }
        println!("{row}");
    }
}

fn main() {
    let mut shop = Shop { prices: HashMap::from([("tea", 20), ("cake", 50)]), cart: vec![], stored_total: 0 };
    println!("{:<22} {:<15} {:>6} {:>9}", "step", "cart", "stored", "computed");
    let note = shop.add("tea", 2);
    shop.show("add 2 tea", &note);
    let note = shop.add("cake", 1);
    shop.show("add 1 cake", &note);
    shop.prices.insert("tea", 25); // the shop changes a price: data changes, the cart doesn't
    shop.show("tea price 20 -> 25", "");
    let note = shop.add("tea", -1);
    shop.show("remove 1 tea", &note);
    let note = shop.add("cake", 9);
    shop.show("add 9 cake", &note);
    if shop.stored_total != shop.computed_total() {
        println!("the stored total is off by {} taka", shop.computed_total() - shop.stored_total);
    }
}

# Data: facts the business keeps. They change rarely, and not because of this user.
prices = {"tea": 20, "cake": 50}

MAX_PER_ITEM = 5  # logic: a rule about what is allowed

# State: this user's cart right now. Every request may change it.
cart = {}  # item -> qty, in the order items were added
stored_total = 0  # a second copy of the total, kept up to date by hand


def computed_total():
    """Computation: derive the total from the state and the data, every time it's needed."""
    return sum(qty * prices[item] for item, qty in cart.items())


def add(item, qty):
    """Applies the logic, then changes the state (and tries to keep stored_total in step).
    A negative qty removes items."""
    global stored_total
    have = cart.get(item, 0)
    if have + qty > MAX_PER_ITEM:
        return f"refused: at most {MAX_PER_ITEM} per item"
    if have + qty == 0:
        del cart[item]
    else:
        cart[item] = have + qty
    stored_total += qty * prices[item]
    return ""


def show(step, note):
    items = ", ".join(f"{item} x{qty}" for item, qty in cart.items())
    row = f"{step:<22} {items:<15} {stored_total:>6} {computed_total():>9}"
    if note:
        row += f"  {note}"
    print(row)


print(f"{'step':<22} {'cart':<15} {'stored':>6} {'computed':>9}")
show("add 2 tea", add("tea", 2))
show("add 1 cake", add("cake", 1))
prices["tea"] = 25  # the shop changes a price: data changes, the cart doesn't
show("tea price 20 -> 25", "")
show("remove 1 tea", add("tea", -1))
show("add 9 cake", add("cake", 9))
if stored_total != computed_total():
    print(f"the stored total is off by {computed_total() - stored_total} taka")

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    // Data: facts the business keeps. They change rarely, and not because of this user.
    static final Map<String, Integer> PRICES = new HashMap<>(Map.of("tea", 20, "cake", 50));

    static final int MAX_PER_ITEM = 5; // logic: a rule about what is allowed

    // State: this user's cart right now. Every request may change it.
    static final Map<String, Integer> CART = new LinkedHashMap<>(); // item -> qty, in the order added
    static int storedTotal = 0; // a second copy of the total, kept up to date by hand

    // Computation: derive the total from the state and the data, every time it's needed.
    static int computedTotal() {
        return CART.entrySet().stream().mapToInt(e -> e.getValue() * PRICES.get(e.getKey())).sum();
    }

    // add applies the logic, then changes the state (and tries to keep storedTotal in step).
    // A negative qty removes items.
    static String add(String item, int qty) {
        int have = CART.getOrDefault(item, 0);
        if (have + qty > MAX_PER_ITEM) return "refused: at most " + MAX_PER_ITEM + " per item";
        if (have + qty == 0) CART.remove(item);
        else CART.put(item, have + qty);
        storedTotal += qty * PRICES.get(item);
        return "";
    }

    static void show(String step, String note) {
        String items = CART.entrySet().stream().map(e -> e.getKey() + " x" + e.getValue()).collect(Collectors.joining(", "));
        String row = String.format("%-22s %-15s %6d %9d", step, items, storedTotal, computedTotal());
        if (!note.isEmpty()) row += "  " + note;
        System.out.println(row);
    }

    public static void main(String[] args) {
        System.out.printf("%-22s %-15s %6s %9s%n", "step", "cart", "stored", "computed");
        show("add 2 tea", add("tea", 2));
        show("add 1 cake", add("cake", 1));
        PRICES.put("tea", 25); // the shop changes a price: data changes, the cart doesn't
        show("tea price 20 -> 25", "");
        show("remove 1 tea", add("tea", -1));
        show("add 9 cake", add("cake", 9));
        if (storedTotal != computedTotal()) {
            System.out.println("the stored total is off by " + (computedTotal() - storedTotal) + " taka");
        }
    }
}