--- title: "15.4 Generic methods" description: "Implementing methods on generic types with impl blocks, and writing methods that exist only for a specific instantiation like Point." url: "https://learnrust.net/chapter-15/generic-methods/" last_updated: "2026-06-13" --- # 15.4 Generic methods A generic struct holds data of type `T`; to give it behavior, you write methods in an `impl` block, just like chapter 10. The only new wrinkle is that the `impl` itself has to be generic, and once you see why, a useful trick falls out: you can write methods that exist *only* for certain concrete types. ## impl blocks on generic types To add methods to `Point`, the `impl` block must declare the type parameter too: ```rust struct Point { x: T, y: T, } impl Point { fn x(&self) -> &T { &self.x } } fn main() { let p = Point { x: 5, y: 10 }; println!("{}", p.x()); } ``` ``` 5 ``` Read the line carefully: `impl Point`. The first `` declares a type parameter for the `impl` block, and `Point` says "for `Point` of that type." You need both because the `impl` is itself generic; it provides this method for `Point` *whatever* `T` is. The method `x` returns `&T`, a reference to the field, and works for `Point`, `Point`, any `Point`. This is the lesson [10.5](https://learnrust.net/chapter-10/methods-and-impl-blocks/) method syntax, with `` threaded through so the compiler knows the `T` in the method body is the same `T` as the struct's. Inside such a method, `T` is still opaque: you can move it, return references to it, store it, but you can't compare or print it without a bound (the same rule as generic functions, lesson [15.2](https://learnrust.net/chapter-15/generic-functions/)). `Point::x` only hands back a reference, so no bound is needed. ## Methods for a specific type only Here's the trick. An `impl` block doesn't have to be generic. You can write `impl Point` (a concrete type, no ``), and the methods inside it exist *only* for `Point`, not for `Point` or any other instantiation: ```rust impl Point { fn distance_from_origin(&self) -> f64 { (self.x * self.x + self.y * self.y).sqrt() } } fn main() { let float_point = Point { x: 3.0, y: 4.0 }; println!("{}", float_point.distance_from_origin()); let int_point = Point { x: 3, y: 4 }; // int_point.distance_from_origin(); // refused: only Point has it } ``` ``` 5 ``` `distance_from_origin` calls `.sqrt()`, which exists for `f64` but not `i32`, so it only makes sense for `Point`. By writing `impl Point` instead of `impl Point`, you give the method to *just* that type. Call it on a `Point` and the compiler says the method doesn't exist, because for `Point` it genuinely doesn't. This lets a generic type offer extra capabilities for the specific types that can support them, without forcing every instantiation to have them. > **Key insight** > > `impl Point` adds a method to *every* `Point`; `impl Point` adds a method to *only* `Point`. The first is for behavior that works regardless of `T`; the second is for behavior that needs a specific type's capabilities (like `f64`'s `sqrt`). You'll see both in the standard library: most of `Vec`'s methods are generic over its element type, but some exist only when the elements meet certain conditions, the more general version of this same idea (which chapter 16's trait bounds make fully expressive). ## Methods can have their own generics A method can also introduce type parameters of its own, separate from the struct's. This is rarer but worth recognizing: the method's `` is independent of the struct's ``. ```rust impl Point { fn pair_with(self, other: U) -> (T, U) { (self.x, other) } } ``` `pair_with` is generic over `U`, a type chosen fresh at the call, distinct from the `Point`'s `T`. It takes `self` by value (consuming the point, lesson [10.5](https://learnrust.net/chapter-10/methods-and-impl-blocks/)) and returns a tuple of the point's `x` and the other value. You won't write these often, but they explain method signatures like `Option::map` that carry their own type parameters beyond the type they're defined on. ## Quiz time **Question #1** Why does an `impl` block on a generic struct need to be written `impl Point` rather than just `impl Point`?
Show solution Because `Point` by itself isn't a complete type; it's `Point` for some `T`. The leading `impl` declares the type parameter so the block can talk about `Point` generically and so the `T` used in the method bodies refers to the struct's type parameter. `impl Point` alone wouldn't name the parameter.
**Question #2** What's the difference between `impl Point` and `impl Point`?
Show solution `impl Point` defines methods available on *every* `Point`, whatever its type. `impl Point` defines methods available *only* on `Point`. The concrete-type `impl` is how you give a method to one instantiation that needs that type's specific capabilities (like `f64::sqrt`), without requiring all instantiations to support it.
**Question #3** You have a `Wrapper` and want a `describe` method on *all* wrappers plus a `sqrt` method only on `Wrapper`. Sketch the two `impl` headers.
Show solution ```rust impl Wrapper { fn describe(&self) -> &str { "a wrapper" } } impl Wrapper { fn sqrt(&self) -> f64 { self.value.sqrt() } } ``` The first (`impl`) gives `describe` to every `Wrapper`; the second (`impl Wrapper`) gives `sqrt` only to the `f64` instantiation, where `.sqrt()` is available.
You can now write generic types and methods. There's one question left that's bothered careful readers since lesson [15.1](https://learnrust.net/chapter-15/the-problem-generics-solve/): if one generic function serves many types, what does the compiled program actually contain? The next lesson answers it, and explains why Rust's generics are "zero-cost." ## Sitemap See the full [sitemap](https://learnrust.net/sitemap.md) for all pages.