If you’ve written Rust for more than five minutes, you’ve met this error: At first glance, it feels nitpicky. You know both values are “basically the same thing”. Rust disagrees—and it’s doing so for a very good reason. Let’s break down what this error actually means and how to think about it like a Rustacean. […]
If you’ve worked with Rust closures, you’ve probably encountered a peculiar problem: how do you return one from a function? The answer lies in understanding one of Rust’s clever features: the impl keyword in return position. The Hidden Complexity of Closures Here’s something that might surprise you: every closure in Rust has its own unique, […]
One of the most important design lessons in Rust is this: you rarely want to choose between generics or dyn Trait globally. The strongest Rust systems use both, deliberately, at different layers. This approach is often called the hybrid trait pattern, and it’s the sweet spot between performance and architectural sanity. The Problem: Generics Don’t […]
If you have ever looked at the code for a Rust web framework like Axum or Actix Web, you’ve seen the “Handler Pattern” in action. You define a function that does specific business logic, and somehow the framework knows exactly when to call it and what data to feed it. Often, this seems like magic. […]
When you’re writing Rust functions, it’s tempting to bake specific behaviour directly into the implementation. But what happens when requirements change? You end up with duplicate functions or sprawling conditional logic. There’s a better way: separate the mechanism from the policy. The Problem: Hardcoded Behaviour Consider a simple event processor that extracts payloads from a […]
Understanding Handlers, Dispatch Tables, and Function Pointers If you’re learning Rust and you keep seeing the word handler, here’s the plain truth: A handler is just a function that gets called in response to something happening. That “something” could be: The key idea is you don’t call the handler directly.Some other part of the program […]
If you’ve ever looked at Rust MCP server code and seen ToolRouter<Self>, you might have been like “wtf, how can a struct contain itself? Isn’t that circular?” Let’s break down this elegant pattern that’s actually simpler than it looks. This does involve function pointers, which leads on to “why do we even want to use […]
What You’ll Learn By the end of this tutorial, you’ll understand how to build a Model Context Protocol (MCP) server in Rust that exposes tools AI assistants can use. We’ll build a simple calculator service with four operations. Prerequisites What is MCP? The Model Context Protocol (MCP) is a standard that allows AI assistants to […]
Zero-Sized Types in Rust, Explained Through the Facade Pattern One of Rust’s most surprising features is the Zero-Sized Type (ZST): a type that occupies no memory at runtime, yet still behaves like a real value. This seems paradoxical at first—how can something that takes no space still exist? The answer lies in understanding that in […]
This article explains why and how to use wrappers (like Parameters<T>) in Rust, and why destructuring is so powerful when working with them. Example Setup Here: Why Use Destructuring? 1️⃣ Easy Access to Inner Value Without destructuring, you’d need .0: Destructuring gives a named variable immediately: 2️⃣ Works Generically for Any T Your wrapper can […]