Remove serialize example, it requires too much setup with the '..' pl…

…aceholders

compiler/noirc_frontend/src/tests.rs

@@ -3423,32 +3423,6 @@ fn errors_on_unused_function() {
     assert_eq!(*item_type, "function");
 }
 
-#[test]
-fn arithmetic_generics_example() {
-    let src = r#"
-// docs:start:arithmetic-generics
-trait Serialize<let N: u32> {
-    fn serialize(self) -> [Field; N];
-}
-
-impl Serialize<1> for Field { .. }
-
-impl<T, let N: u32, M: u32> Serialize<N * M> for [T; N]
-    where T: Serialize<M> { .. }
-
-impl<T, U, let N: u32, M: u32> Serialize<N + M> for (T, U)
-    where T: Serialize<N>, U: Serialize<M> { .. }
-
-fn main() {
-    let data = (1, [2, 3, 4]);
-    assert(data.serialize().len(), 4);
-}
-// docs:end:arithmetic-generics
-    "#;
-
-    assert_no_errors(src);
-}
-
 #[test]
 fn constrained_reference_to_unconstrained() {
     let src = r#"

docs/docs/noir/concepts/generics.md

@@ -178,7 +178,28 @@ apply the distributive law and thus sees these as different types.
 
 Even with this limitation though, the compiler can handle common cases decently well:
 
-#include_code arithmetic-generics compiler/noirc_frontend/src/tests.rs rust
+```rust
+trait Serialize<let N: u32> {
+    fn serialize(self) -> [Field; N];
+}
+
+impl Serialize<1> for Field {
+    fn serialize(self) -> [Field; 1] {
+        [self]
+    }
+}
+
+impl<T, let N: u32, M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> { .. }
+
+impl<T, U, let N: u32, M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> { .. }
+
+fn main() {
+    let data = (1, [2, 3, 4]);
+    assert(data.serialize().len(), 4);
+}
+```
 
 Note that if there is any over or underflow the types will fail to unify: