chore(docs): address visibility issues in docs

docs/docs/language_concepts/01_functions.md

@@ -30,15 +30,15 @@
 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
 }
 ```
@@ -197,7 +197,7 @@
 The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
 As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
 
 Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
 
 ```rust
 #[field(bn254)]

docs/docs/language_concepts/07_mutability.md

@@ -37,7 +37,7 @@
 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
@@ -69,11 +69,11 @@
 
     assert(res == y[0]);
 
     let res2 = x * mysubmodule::N;
     assert(res != res2);
 }
 
 mod mysubmodule {
     use dep::std;
 
     global N: Field = 10;

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 @@
 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
@@ -69,11 +69,11 @@
 
     assert(res == y[0]);
 
     let res2 = x * mysubmodule::N;
     assert(res != res2);
 }
 
 mod mysubmodule {
     use dep::std;
 
     global N: Field = 10;

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

@@ -30,15 +30,15 @@
 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
 }
 ```
@@ -197,7 +197,7 @@
 The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
 As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
 
 Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
 
 ```rust
 #[field(bn254)]

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

@@ -37,7 +37,7 @@
 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
@@ -69,11 +69,11 @@
 
     assert(res == y[0]);
 
     let res2 = x * mysubmodule::N;
     assert(res != res2);
 }
 
 mod mysubmodule {
     use dep::std;
 
     global N: Field = 10;

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

@@ -30,15 +30,15 @@
 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
 }
 ```
@@ -197,7 +197,7 @@
 The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
 As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
 
 Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
 
 ```rust
 #[field(bn254)]

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

@@ -37,7 +37,7 @@
 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
@@ -69,7 +69,7 @@
 
     assert(res == y[0]);
 
     let res2 = x * mysubmodule::N;
     assert(res != res2);
 }
 

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