Сущность

//entity
struct OrderLine {
    sku: String,
    price: i64,
    count: i64,
}

impl OrderLine {
    //Rust has no exceptions: a broken rule comes back
    //as a value, and the caller cannot ignore it
    fn new(sku: &str, price: i64, count: i64)
        -> Result<OrderLine, String> {
        if count <= 0 {
            return Err(format!("bad count for {}", sku));
        }
        Ok(OrderLine {
            sku: sku.to_string(),
            price,
            count,
        })
    }

    fn cost(&self) -> i64 {
        self.price * self.count
    }
}

//entity
struct Order {
    id: i64,
    lines: Vec<OrderLine>,
    paid: bool,
}

impl Order {
    fn new(id: i64) -> Order {
        Order {
            id,
            lines: Vec::new(),
            paid: false,
        }
    }

    //adding changes the order, so it asks for &mut self;
    //reading rules below is enough with &self
    fn add(&mut self, line: OrderLine) {
        self.lines.push(line);
    }

    fn goods(&self) -> String {
        let names: Vec<&str> = self.lines.iter()
            .map(|line| line.sku.as_str())
            .collect();
        names.join(" ")
    }

    fn total(&self) -> i64 {
        self.lines.iter().map(|line| line.cost()).sum()
    }

    //business rule: 10% off from 200
    fn discount(&self) -> i64 {
        let total = self.total();
        if total >= 200 {
            total / 10
        } else {
            0
        }
    }

    fn payable(&self) -> i64 {
        self.total() - self.discount()
    }

    //business rule: an empty order is never paid
    fn pay(&mut self) -> Result<(), String> {
        if self.lines.is_empty() {
            return Err("empty order".to_string());
        }
        self.paid = true;
        Ok(())
    }
}

//client code
//no database and no screen anywhere above
let mut order = Order::new(1001);
order.add(OrderLine::new("pen", 30, 2).unwrap());
order.add(OrderLine::new("lamp", 190, 1).unwrap());
println!("order {}", order.id);
println!("lines {}", order.lines.len());
println!("goods {}", order.goods());
println!("total {}", order.total());
println!("discount {}", order.discount());
println!("payable {}", order.payable());
order.pay().unwrap();
println!("paid {}", order.paid);

match OrderLine::new("pen", 30, 0) {
    Ok(_) => println!("line added"),
    Err(reason) => println!("refused: {}", reason),
}
match Order::new(1002).pay() {
    Ok(()) => println!("paid"),
    Err(reason) => println!("refused: {}", reason),
}
//printed: order 1001
//         lines 2
//         goods pen lamp
//         total 250
//         discount 25
//         payable 225
//         paid true
//         refused: bad count for pen
//         refused: empty order