The best part about Rust is the type system. For one example, in a web app I'm building for a client, we have two types to represent invoice ids: one for the i

The best part about Rust is the type system. For one example, in a web app I'm building for a client, we have two types to represent invoice ids: one for the invoice id that came back in a response from the API, and one for an invoice id that a user is asking for. They are distinct because we know that an InvoiceId refers to an actual invoice in the system, and a UnverifiedInvoiceId might not. Both of them are distinct from a CustomerId or any other id. This might sound like it could get cumbersome fast, but it's actually really simple in practice, due to clever uses of traits. UnverifiedInvoiceId implements rocket::FromParam, so I can deserialize it from a URL parameter. InvoiceId is only created in the serde::Deserialize implementation of an invoice-returning API response. So a (significantly simplified) endpoint in the app might look like: #[get("/invoices/<unverified_invoice_id>")] pub fn get_invoice_by_id( unverified_invoice_id: UnverifiedInvoiceId, api_conn: ApiConnection, ) -> HtmlResponse { // API "search" methods take unverified user input as parameters let invoice = api_conn.fetch_invoice_by_id(unverified_invoice_id); // API "lookup" methods take verified ids let line_items = api_conn.fetch_invoice_line_items(invoice.id); render_invoice(invoice, line_items); } I can't accidentally switch up things that don't belong together, even though under the hood they're all just unsigned ints.