chore(docs): address visibility issues in docs

docs/docs/language_concepts/01_functions.md

@@ -30,15 +30,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/docs/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.10.5/language_concepts/01_functions.md

@@ -18,15 +18,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.10.5/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.17.0/language_concepts/01_functions.md

@@ -30,15 +30,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.17.0/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.19.0/language_concepts/01_functions.md

@@ -30,15 +30,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.19.0/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.19.1/language_concepts/01_functions.md

@@ -30,15 +30,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.19.1/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.19.2/language_concepts/01_functions.md

@@ -30,15 +30,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.19.2/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.19.3/language_concepts/01_functions.md

@@ -30,15 +30,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.19.3/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.19.4/language_concepts/01_functions.md

@@ -30,15 +30,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.19.4/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.6.0/language_concepts/01_functions.md

@@ -18,15 +18,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.6.0/language_concepts/07_mutability.md

@@ -39,7 +39,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.7.1/language_concepts/01_functions.md

@@ -18,15 +18,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.7.1/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3

docs/versioned_docs/version-v0.9.0/language_concepts/01_functions.md

@@ -18,15 +18,15 @@ All parameters in a function must have a type and all types are known at compile
 is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
 
 ```rust
-fn foo(x : Field, y : pub Field){}
+fn foo(x : Field, y : Field){}
 ```
 
 The return type of a function can be stated by using the `->` arrow notation. The function below
 states that the foo function must return a `Field`. If the function returns no value, then the arrow
 is omitted.
 
 ```rust
-fn foo(x : Field, y : pub Field) -> Field {
+fn foo(x : Field, y : Field) -> Field {
     x + y
 }
 ```

docs/versioned_docs/version-v0.9.0/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@ Note that mutability in noir is local and everything is passed by value, so if a
 mutates its parameters then the parent function will keep the old value of the parameters.
 
 ```rust
-fn main() -> Field {
+fn main() -> pub Field {
     let x = 3;
     helper(x);
     x // x is still 3