Coming From Another Language: Go

package main

import "fmt"

type Order struct {
	Item  string
	Qty   int
	Cents int
}

func (o Order) Cost() int {
	return o.Qty * o.Cents
}

type BadQty struct {
	Item string
}

func (e BadQty) Error() string {
	return "no quantity for " + e.Item
}

func total(orders []Order) (int, error) {
	sum := 0
	for _, o := range orders {
		if o.Qty <= 0 {
			return 0, BadQty{Item: o.Item}
		}
		sum += o.Cost()
	}
	return sum, nil
}

func main() {
	codes := map[string]int{"SPRING": 10, "VIP": 25}
	orders := []Order{{"pen", 3, 150}, {"cup", 1, 900}}

	sum, err := total(orders)
	if err != nil {
		sum = 0
	}
	off := codes["SPRING"]
	fmt.Printf("total %d, with %d%% off %d\n", sum, off, sum*(100-off)/100)
	fmt.Printf("WINTER gives %d%%\n", codes["WINTER"])

	broken := []Order{{"kite", 0, 500}}
	if t, err := total(broken); err != nil {
		if bad, ok := err.(BadQty); ok {
			fmt.Printf("refused: no quantity for %s\n", bad.Item)
		}
	} else {
		fmt.Printf("total %d\n", t)
	}
}

type Order {
    item: String
    qty: Int
    cents: Int

    fn cost(self) -> Int {
        self.qty * self.cents
    }
}

type OrderError = BadQty(item: String)

fn total(orders: [Order]) -> Int ! OrderError {
    for o in orders {
        if o.qty <= 0 {
            fail OrderError.BadQty(item: o.item)
        }
    }
    orders.sum(o => o.cost())
}

fn main() {
    const codes = ["SPRING": 10, "VIP": 25]
    const orders = [Order(item: "pen", qty: 3, cents: 150), Order(item: "cup", qty: 1, cents: 900)]

    const sum = total(orders) catch _ => 0
    const off = codes["SPRING"] ?? 0
    print("total {sum}, with {off}% off {sum * (100 - off) / 100}")
    print("WINTER gives {codes["WINTER"] ?? 0}%")

    const broken = [Order(item: "kite", qty: 0, cents: 500)]
    match total(broken) {
        ok(t) => print("total {t}"),
        err(OrderError.BadQty(item)) => print("refused: no quantity for {item}"),
    }
}