From 77deab427b985cabbda5215e06b194547000bc03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro=20Sousa?= <jose@aztecprotocol.com>
Date: Tue, 24 Oct 2023 17:30:55 +0100
Subject: [PATCH] chore: method specialization (#3268)

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 docs/docs/language_concepts/01_functions.md | 28 +++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/docs/docs/language_concepts/01_functions.md b/docs/docs/language_concepts/01_functions.md
index 2d7cc95a36d..c42aa9eab12 100644
--- a/docs/docs/language_concepts/01_functions.md
+++ b/docs/docs/language_concepts/01_functions.md
@@ -138,6 +138,34 @@ follows:
 assert(MyStruct::sum(s) == 42);
 ```
 
+It is also possible to specialize which method is chosen depending on the [generic](./06_generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rs
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
 ## Lambdas
 
 Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.