From de0f8eeeeaa2f35b6d1e3b7f77cd3e4a1b2db9ba Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 23 Aug 2024 16:38:57 -0500
Subject: [PATCH] chore: Add docs for each comptime method (#5802)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Adds docs for each comptime method that's been added.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: TomAFrench <tom@tomfren.ch>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 cspell.json                                   |   4 +-
 docs/docs/noir/standard_library/meta/expr.md  | 149 ++++++++++++++++++
 .../standard_library/meta/function_def.md     |  55 +++++++
 docs/docs/noir/standard_library/meta/index.md | 141 +++++++++++++++++
 .../docs/noir/standard_library/meta/module.md |  27 ++++
 docs/docs/noir/standard_library/meta/op.md    | 134 ++++++++++++++++
 .../docs/noir/standard_library/meta/quoted.md |  57 +++++++
 .../noir/standard_library/meta/struct_def.md  |  45 ++++++
 .../standard_library/meta/trait_constraint.md |  17 ++
 .../noir/standard_library/meta/trait_def.md   |  22 +++
 .../noir/standard_library/meta/trait_impl.md  |  52 ++++++
 docs/docs/noir/standard_library/meta/typ.md   | 126 +++++++++++++++
 noir_stdlib/src/cmp.nr                        |   4 +
 noir_stdlib/src/hash/mod.nr                   |   2 +
 noir_stdlib/src/meta/expr.nr                  |  48 +++++-
 noir_stdlib/src/meta/function_def.nr          |  12 ++
 noir_stdlib/src/meta/mod.nr                   |  10 ++
 noir_stdlib/src/meta/module.nr                |   6 +
 noir_stdlib/src/meta/op.nr                    |  80 +++++++---
 noir_stdlib/src/meta/quoted.nr                |   8 +
 noir_stdlib/src/meta/struct_def.nr            |   6 +
 noir_stdlib/src/meta/trait_def.nr             |   2 +
 noir_stdlib/src/meta/trait_impl.nr            |   4 +
 noir_stdlib/src/meta/typ.nr                   |  20 +++
 .../comptime_module/src/main.nr               |  15 ++
 .../comptime_type/src/main.nr                 |   2 +
 26 files changed, 1024 insertions(+), 24 deletions(-)
 create mode 100644 docs/docs/noir/standard_library/meta/expr.md
 create mode 100644 docs/docs/noir/standard_library/meta/function_def.md
 create mode 100644 docs/docs/noir/standard_library/meta/index.md
 create mode 100644 docs/docs/noir/standard_library/meta/module.md
 create mode 100644 docs/docs/noir/standard_library/meta/op.md
 create mode 100644 docs/docs/noir/standard_library/meta/quoted.md
 create mode 100644 docs/docs/noir/standard_library/meta/struct_def.md
 create mode 100644 docs/docs/noir/standard_library/meta/trait_constraint.md
 create mode 100644 docs/docs/noir/standard_library/meta/trait_def.md
 create mode 100644 docs/docs/noir/standard_library/meta/trait_impl.md
 create mode 100644 docs/docs/noir/standard_library/meta/typ.md

diff --git a/cspell.json b/cspell.json
index 055943e8e48..467ae85f8ca 100644
--- a/cspell.json
+++ b/cspell.json
@@ -119,6 +119,7 @@
         "keccakf",
         "krate",
         "libc",
+        "Linea",
         "losslessly",
         "lvalue",
         "Maddiaa",
@@ -220,8 +221,7 @@
         "wasi",
         "wasmer",
         "Weierstraß",
-        "zshell",
-        "Linea"
+        "zshell"
     ],
     "ignorePaths": [
         "./**/node_modules/**",
diff --git a/docs/docs/noir/standard_library/meta/expr.md b/docs/docs/noir/standard_library/meta/expr.md
new file mode 100644
index 00000000000..bcc9756c06c
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/expr.md
@@ -0,0 +1,149 @@
+---
+title: Expr
+---
+
+`std::meta::expr` contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
+
+## Methods
+
+### as_array
+
+#include_code as_array noir_stdlib/src/meta/expr.nr rust
+
+If this expression is an array, this returns a slice of each element in the array.
+
+### as_integer
+
+#include_code as_integer noir_stdlib/src/meta/expr.nr rust
+
+If this element is an integer literal, return the integer as a field
+as well as whether the integer is negative (true) or not (false).
+
+### as_binary_op
+
+#include_code as_binary_op noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a binary operator operation `<lhs> <op> <rhs>`,
+return the left-hand side, operator, and the right-hand side of the operation.
+
+### as_block
+
+#include_code as_block noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
+a slice containing each statement.
+
+### as_bool
+
+#include_code as_bool noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a boolean literal, return that literal.
+
+### as_comptime
+
+#include_code as_comptime noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
+return each statement in the block.
+
+### as_function_call
+
+#include_code as_function_call noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a function call `foo(arg1, ..., argN)`, return
+the function and a slice of each argument.
+
+### as_if
+
+#include_code as_if noir_stdlib/src/meta/expr.nr rust
+
+If this expression is an `if condition { then_branch } else { else_branch }`,
+return the condition, then branch, and else branch. If there is no else branch,
+`None` is returned for that branch instead.
+
+### as_index
+
+#include_code as_index noir_stdlib/src/meta/expr.nr rust
+
+If this expression is an index into an array `array[index]`, return the
+array and the index.
+
+### as_member_access
+
+#include_code as_member_access noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a member access `foo.bar`, return the struct/tuple
+expression and the field. The field will be represented as a quoted value.
+
+### as_repeated_element_array
+
+#include_code as_repeated_element_array noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a repeated element array `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_repeated_element_slice
+
+#include_code as_repeated_element_slice noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a repeated element slice `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_slice
+
+#include_code as_slice noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a slice literal `&[elem1, ..., elemN]`,
+return each element of the slice.
+
+### as_tuple
+
+#include_code as_tuple noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a tuple `(field1, ..., fieldN)`,
+return each element of the tuple.
+
+### as_unary_op
+
+#include_code as_unary_op noir_stdlib/src/meta/expr.nr rust
+
+If this expression is a unary operation `<op> <rhs>`,
+return the unary operator as well as the right-hand side expression.
+
+### as_unsafe
+
+#include_code as_unsafe noir_stdlib/src/meta/expr.nr rust
+
+If this expression is an `unsafe { stmt1; ...; stmtN }` block,
+return each statement inside in a slice.
+
+### has_semicolon
+
+#include_code has_semicolon noir_stdlib/src/meta/expr.nr rust
+
+`true` if this expression is trailed by a semicolon. E.g.
+
+```
+comptime {
+    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
+    let expr2 = quote { 1 + 2; }.as_expr().unwrap();
+
+    assert(expr1.as_binary_op().is_some());
+    assert(expr2.as_binary_op().is_some());
+
+    assert(!expr1.has_semicolon());
+    assert(expr2.has_semicolon());
+}
+```
+
+### is_break
+
+#include_code is_break noir_stdlib/src/meta/expr.nr rust
+
+`true` if this expression is `break`.
+
+### is_continue
+
+#include_code is_continue noir_stdlib/src/meta/expr.nr rust
+
+`true` if this expression is `continue`.
diff --git a/docs/docs/noir/standard_library/meta/function_def.md b/docs/docs/noir/standard_library/meta/function_def.md
new file mode 100644
index 00000000000..4b359a9d343
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/function_def.md
@@ -0,0 +1,55 @@
+---
+title: FunctionDefinition
+---
+
+`std::meta::function_def` contains methods on the built-in `FunctionDefinition` type representing
+a function definition in the source program.
+
+## Methods
+
+### name
+
+#include_code name noir_stdlib/src/meta/function_def.nr rust
+
+Returns the name of the function.
+
+### parameters
+
+#include_code parameters noir_stdlib/src/meta/function_def.nr rust
+
+Returns each parameter of the function as a tuple of (parameter pattern, parameter type).
+
+### return_type
+
+#include_code return_type noir_stdlib/src/meta/function_def.nr rust
+
+The return type of the function.
+
+### set_body
+
+#include_code set_body noir_stdlib/src/meta/function_def.nr rust
+
+Mutate the function body to a new expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Requires the new body to be a valid expression.
+
+### set_parameters
+
+#include_code set_parameters noir_stdlib/src/meta/function_def.nr rust
+
+Mutates the function's parameters to a new set of parameters. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Expects a slice of (parameter pattern, parameter type) for each parameter. Requires
+each parameter pattern to be a syntactically valid parameter.
+
+### set_return_type
+
+#include_code set_return_type noir_stdlib/src/meta/function_def.nr rust
+
+Mutates the function's return type to a new type. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
diff --git a/docs/docs/noir/standard_library/meta/index.md b/docs/docs/noir/standard_library/meta/index.md
new file mode 100644
index 00000000000..db0e5d0e411
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/index.md
@@ -0,0 +1,141 @@
+---
+title: Metaprogramming
+description: Noir's Metaprogramming API
+keywords: [metaprogramming, comptime, macros, macro, quote, unquote]
+---
+
+`std::meta` is the entry point for Noir's metaprogramming API. This consists of `comptime` functions
+and types used for inspecting and modifying Noir programs.
+
+## Functions
+
+### type_of
+
+#include_code type_of noir_stdlib/src/meta/mod.nr rust
+
+Returns the type of a variable at compile-time.
+
+Example:
+```rust
+comptime {
+    let x: i32 = 1;
+    let x_type: Type = std::meta::type_of(x);
+
+    assert_eq(x_type, quote { i32 }.as_type());
+}
+```
+
+### unquote
+
+#include_code unquote noir_stdlib/src/meta/mod.nr rust
+
+Unquotes the passed-in token stream where this function was called.
+
+Example:
+```rust
+comptime {
+    let code = quote { 1 + 2 };
+
+    // let x = 1 + 2;
+    let x = unquote!(code);
+}
+```
+
+### derive
+
+#include_code derive noir_stdlib/src/meta/mod.nr rust
+
+Attribute placed on struct definitions.
+
+Creates a trait impl for each trait passed in as an argument.
+To do this, the trait must have a derive handler registered
+with `derive_via` beforehand. The traits in the stdlib that
+can be derived this way are `Eq`, `Ord`, `Default`, and `Hash`.
+
+Example:
+```rust
+#[derive(Eq, Default)]
+struct Foo<T> {
+    x: i32,
+    y: T,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    let foo2 = Foo { x: 0, y: &[0] };
+    assert_eq(foo1, foo2);
+}
+```
+
+### derive_via
+
+#include_code derive_via_signature noir_stdlib/src/meta/mod.nr rust
+
+Attribute placed on trait definitions.
+
+Registers a function to create impls for the given trait
+when the trait is used in a `derive` call. Users may use
+this to register their own functions to enable their traits
+to be derived by `derive`.
+
+Because this function requires a function as an argument which
+should produce a trait impl for any given struct, users may find
+it helpful to use a function like `std::meta::make_trait_impl` to
+help creating these impls.
+
+Example:
+```rust
+#[derive_via(derive_do_nothing)]
+trait DoNothing {
+    fn do_nothing(self);
+}
+
+comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl DoNothing for $typ {
+            fn do_nothing(self) {
+                println("Nothing");
+            }
+        }
+    }
+}
+```
+
+As another example, `derive_eq` in the stdlib is used to derive the `Eq`
+trait for any struct. It makes use of `make_trait_impl` to do this:
+
+#include_code derive_eq noir_stdlib/src/cmp.nr rust
+
+### make_trait_impl
+
+#include_code make_trait_impl noir_stdlib/src/meta/mod.nr rust
+
+A helper function to more easily create trait impls while deriving traits.
+
+Note that this function only works for traits which:
+1. Have only one method
+2. Have no generics on the trait itself.
+  - E.g. Using this on a trait such as `trait Foo<T> { ... }` will result in the
+    generated impl incorrectly missing the `T` generic.
+
+If your trait fits these criteria then `make_trait_impl` is likely the easiest
+way to write your derive handler. The arguments are as follows:
+
+- `s`: The struct to make the impl for
+- `trait_name`: The name of the trait to derive. E.g. `quote { Eq }`.
+- `function_signature`: The signature of the trait method to derive. E.g. `fn eq(self, other: Self) -> bool`.
+- `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
+- `join_fields_with`: A separator to join each result of `for_each_field` with.
+  E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
+- `body`: The result of the field operations are passed into this function for any final processing.
+  This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
+  any such code, you can return the body as-is: `|body| body`.
+
+Example deriving `Hash`:
+
+#include_code derive_hash noir_stdlib/src/hash/mod.nr rust
+
+Example deriving `Ord`:
+
+#include_code derive_ord noir_stdlib/src/cmp.nr rust
diff --git a/docs/docs/noir/standard_library/meta/module.md b/docs/docs/noir/standard_library/meta/module.md
new file mode 100644
index 00000000000..d283f2da8b2
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/module.md
@@ -0,0 +1,27 @@
+---
+title: Module
+---
+
+`std::meta::module` contains methods on the built-in `Module` type which represents a module in the source program.
+Note that this type represents a module generally, it isn't limited to only `mod my_submodule { ... }`
+declarations in the source program.
+
+## Methods
+
+### name
+
+#include_code name noir_stdlib/src/meta/module.nr rust
+
+Returns the name of the module.
+
+### functions
+
+#include_code functions noir_stdlib/src/meta/module.nr rust
+
+Returns each function in the module.
+
+### is_contract
+
+#include_code is_contract noir_stdlib/src/meta/module.nr rust
+
+`true` if this module is a contract module (was declared via `contract foo { ... }`).
diff --git a/docs/docs/noir/standard_library/meta/op.md b/docs/docs/noir/standard_library/meta/op.md
new file mode 100644
index 00000000000..37d4cb746ac
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/op.md
@@ -0,0 +1,134 @@
+---
+title: UnaryOp and BinaryOp
+---
+
+`std::meta::op` contains the `UnaryOp` and `BinaryOp` types as well as methods on them.
+These types are used to represent a unary or binary operator respectively in Noir source code.
+
+## Types
+
+### UnaryOp
+
+Represents a unary operator. One of `-`, `!`, `&mut`, or `*`.
+
+### Methods
+
+#### is_minus
+
+#include_code is_minus noir_stdlib/src/meta/op.nr rust
+
+Returns `true` if this operator is `-`.
+
+#### is_not
+
+#include_code is_not noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `!`
+
+#### is_mutable_reference
+
+#include_code is_mutable_reference noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `&mut`
+
+#### is_dereference
+
+#include_code is_dereference noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `*`
+
+### BinaryOp
+
+Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `>>`, or `<<`.
+
+### Methods
+
+#### is_add
+
+#include_code is_add noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `+`
+
+#### is_subtract
+
+#include_code is_subtract noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `-`
+
+#### is_multiply
+
+#include_code is_multiply noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `*`
+
+#### is_divide
+
+#include_code is_divide noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `/`
+
+#### is_modulo
+
+#include_code is_modulo noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `%`
+
+#### is_equal
+
+#include_code is_equal noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `==`
+
+#### is_not_equal
+
+#include_code is_not_equal noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `!=`
+
+#### is_less_than
+
+#include_code is_less_than noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `<`
+
+#### is_less_than_or_equal
+
+#include_code is_less_than_or_equal noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `<=`
+
+#### is_greater_than
+
+#include_code is_greater_than noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `>`
+
+#### is_greater_than_or_equal
+
+#include_code is_greater_than_or_equal noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `>=`
+
+#### is_and
+
+#include_code is_and noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `&`
+
+#### is_or
+
+#include_code is_or noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `|`
+
+#### is_shift_right
+
+#include_code is_shift_right noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `>>`
+
+#### is_shift_left
+
+#include_code is_shift_right noir_stdlib/src/meta/op.nr rust
+
+`true` if this operator is `<<`
diff --git a/docs/docs/noir/standard_library/meta/quoted.md b/docs/docs/noir/standard_library/meta/quoted.md
new file mode 100644
index 00000000000..13d27ce8344
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/quoted.md
@@ -0,0 +1,57 @@
+---
+title: Quoted
+---
+
+`std::meta::quoted` contains methods on the built-in `Quoted` type which represents
+quoted token streams and is the result of the `quote { ... }` expression.
+
+## Methods
+
+### as_expr
+
+#include_code as_expr noir_stdlib/src/meta/quoted.nr rust
+
+Parses the quoted token stream as an expression. Returns `Option::none()` if
+the expression failed to parse.
+
+Example:
+
+#include_code as_expr_example noir_stdlib/src/meta/quoted.nr rust
+
+### as_module
+
+#include_code as_module noir_stdlib/src/meta/quoted.nr rust
+
+Interprets this token stream as a module path leading to the name of a module.
+Returns `Option::none()` if the module isn't found or this token stream cannot be parsed as a path.
+
+Example:
+
+#include_code as_module_example test_programs/compile_success_empty/comptime_module/src/main.nr rust
+
+### as_trait_constraint
+
+#include_code as_trait_constraint noir_stdlib/src/meta/quoted.nr rust
+
+Interprets this token stream as a trait constraint (without an object type).
+Note that this function panics instead of returning `Option::none()` if the token
+stream does not parse and resolve to a valid trait constraint.
+
+Example:
+
+#include_code implements_example noir_stdlib/src/meta/quoted.nr rust
+
+### as_type
+
+#include_code as_type noir_stdlib/src/meta/quoted.nr rust
+
+Interprets this token stream as a resolved type. Panics if the token
+stream doesn't parse to a type or if the type isn't a valid type in scope.
+
+#include_code implements_example noir_stdlib/src/meta/quoted.nr rust
+
+## Trait Implementations
+
+```rust
+impl Eq for Quoted
+```
diff --git a/docs/docs/noir/standard_library/meta/struct_def.md b/docs/docs/noir/standard_library/meta/struct_def.md
new file mode 100644
index 00000000000..ab3ea4e0698
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/struct_def.md
@@ -0,0 +1,45 @@
+---
+title: StructDefinition
+---
+
+`std::meta::struct_def` contains methods on the built-in `StructDefinition` type.
+This type corresponds to `struct Name { field1: Type1, ... }` items in the source program.
+
+## Methods
+
+### as_type
+
+#include_code as_type noir_stdlib/src/meta/struct_def.nr rust
+
+Returns this struct as a type in the source program. If this struct has
+any generics, the generics are also included as-is.
+
+### generics
+
+#include_code generics noir_stdlib/src/meta/struct_def.nr rust
+
+Returns each generic on this struct.
+
+Example:
+
+```
+#[example]
+struct Foo<T, U> {
+    bar: [T; 2],
+    baz: Baz<U, U>,
+}
+
+comptime fn example(foo: StructDefinition) {
+    assert_eq(foo.generics().len(), 2);
+
+    // Fails because `T` isn't in scope
+    // let t = quote { T }.as_type();
+    // assert_eq(foo.generics()[0], t);
+}
+```
+
+### fields
+
+#include_code fields noir_stdlib/src/meta/struct_def.nr rust
+
+Returns each field of this struct as a pair of (field name, field type).
diff --git a/docs/docs/noir/standard_library/meta/trait_constraint.md b/docs/docs/noir/standard_library/meta/trait_constraint.md
new file mode 100644
index 00000000000..3106f732b5a
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/trait_constraint.md
@@ -0,0 +1,17 @@
+---
+title: TraitConstraint
+---
+
+`std::meta::trait_constraint` contains methods on the built-in `TraitConstraint` type which represents
+a trait constraint that can be used to search for a trait implementation. This is similar
+syntactically to just the trait itself, but can also contain generic arguments. E.g. `Eq`, `Default`,
+`BuildHasher<Poseidon2Hasher>`.
+
+This type currently has no public methods but it can be used alongside `Type` in `implements` or `get_trait_impl`.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitConstraint
+impl Hash for TraitConstraint
+```
diff --git a/docs/docs/noir/standard_library/meta/trait_def.md b/docs/docs/noir/standard_library/meta/trait_def.md
new file mode 100644
index 00000000000..b6e8bf4ff76
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/trait_def.md
@@ -0,0 +1,22 @@
+---
+title: TraitDefinition
+---
+
+`std::meta::trait_def` contains methods on the built-in `TraitDefinition` type. This type
+represents trait definitions such as `trait Foo { .. }` at the top-level of a program.
+
+## Methods
+
+### as_trait_constraint
+
+#include_code as_trait_constraint noir_stdlib/src/meta/trait_def.nr rust
+
+Converts this trait into a trait constraint. If there are any generics on this
+trait, they will be kept as-is without instantiating or replacing them.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitDefinition
+impl Hash for TraitDefinition
+```
diff --git a/docs/docs/noir/standard_library/meta/trait_impl.md b/docs/docs/noir/standard_library/meta/trait_impl.md
new file mode 100644
index 00000000000..659c6aad719
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/trait_impl.md
@@ -0,0 +1,52 @@
+---
+title: TraitImpl
+---
+
+`std::meta::trait_impl` contains methods on the built-in `TraitImpl` type which represents a trait
+implementation such as `impl Foo for Bar { ... }`.
+
+## Methods
+
+### trait_generic_args
+
+#include_code trait_generic_args noir_stdlib/src/meta/trait_impl.nr rust
+
+Returns any generic arguments on the trait of this trait implementation, if any.
+
+```rs
+impl Foo<i32, Field> for Bar { ... }
+
+comptime {
+    let bar_type = quote { Bar }.as_type();
+    let foo = quote { Foo<i32, Field> }.as_trait_constraint();
+
+    let my_impl: TraitImpl = bar_type.get_trait_impl(foo).unwrap();
+
+    let generics = my_impl.trait_generic_args();
+    assert_eq(generics.len(), 2);
+
+    assert_eq(generics[0], quote { i32 }.as_type());
+    assert_eq(generics[1], quote { Field }.as_type());
+}
+```
+
+### methods
+
+#include_code methods noir_stdlib/src/meta/trait_impl.nr rust
+
+Returns each method in this trait impl.
+
+Example:
+
+```rs
+comptime {
+    let i32_type = quote { i32 }.as_type();
+    let eq = quote { Eq }.as_trait_constraint();
+
+    let impl_eq_for_i32: TraitImpl = i32_type.get_trait_impl(eq).unwrap();
+    let methods = impl_eq_for_i32.methods();
+
+    assert_eq(methods.len(), 1);
+    assert_eq(methods[0].name(), quote { eq });
+}
+```
diff --git a/docs/docs/noir/standard_library/meta/typ.md b/docs/docs/noir/standard_library/meta/typ.md
new file mode 100644
index 00000000000..bad6435e94a
--- /dev/null
+++ b/docs/docs/noir/standard_library/meta/typ.md
@@ -0,0 +1,126 @@
+---
+title: Type
+---
+
+`std::meta::typ` contains methods on the built-in `Type` type used for representing
+a type in the source program.
+
+## Methods
+
+### as_array
+
+#include_code as_array noir_stdlib/src/meta/typ.nr rust
+
+If this type is an array, return a pair of (element type, size type).
+
+Example:
+
+```rust
+comptime {
+    let array_type = quote { [Field; 3] }.as_type();
+    let (field_type, three_type) = array_type.as_array().unwrap();
+
+    assert(field_type.is_field());
+    assert_eq(three_type.as_constant().unwrap(), 3);
+}
+```
+
+### as_constant
+
+#include_code as_constant noir_stdlib/src/meta/typ.nr rust
+
+If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+return the numeric constant.
+
+### as_integer
+
+#include_code as_integer noir_stdlib/src/meta/typ.nr rust
+
+If this is an integer type, return a boolean which is `true`
+if the type is signed, as well as the number of bits of this integer type.
+
+### as_slice
+
+#include_code as_slice noir_stdlib/src/meta/typ.nr rust
+
+If this is a slice type, return the element type of the slice.
+
+### as_struct
+
+#include_code as_struct noir_stdlib/src/meta/typ.nr rust
+
+If this is a struct type, returns the struct in addition to
+any generic arguments on this type.
+
+### as_tuple
+
+#include_code as_tuple noir_stdlib/src/meta/typ.nr rust
+
+If this is a tuple type, returns each element type of the tuple.
+
+### get_trait_impl
+
+#include_code get_trait_impl noir_stdlib/src/meta/typ.nr rust
+
+Retrieves the trait implementation that implements the given
+trait constraint for this type. If the trait constraint is not
+found, `None` is returned. Note that since the concrete trait implementation
+for a trait constraint specified from a `where` clause is unknown,
+this function will return `None` in these cases. If you only want to know
+whether a type implements a trait, use `implements` instead.
+
+Example:
+
+```rust
+comptime {
+    let field_type = quote { Field }.as_type();
+    let default = quote { Default }.as_trait_constraint();
+
+    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    assert(the_impl.methods().len(), 1);
+}
+```
+
+### implements
+
+#include_code implements noir_stdlib/src/meta/typ.nr rust
+
+`true` if this type implements the given trait. Note that unlike
+`get_trait_impl` this will also return true for any `where` constraints
+in scope.
+
+Example:
+
+```rust
+fn foo<T>() where T: Default {
+    comptime {
+        let field_type = quote { Field }.as_type();
+        let default = quote { Default }.as_trait_constraint();
+        assert(field_type.implements(default));
+
+        let t = quote { T }.as_type();
+        assert(t.implements(default));
+    }
+}
+```
+
+### is_bool
+
+#include_code is_bool noir_stdlib/src/meta/typ.nr rust
+
+`true` if this type is `bool`.
+
+### is_field
+
+#include_code is_field noir_stdlib/src/meta/typ.nr rust
+
+`true` if this type is `Field`.
+
+## Trait Implementations
+
+```rust
+impl Eq for Type
+```
+Note that this is syntactic equality, this is not the same as whether two types will type check
+to be the same type. Unless type inference or generics are being used however, users should not
+typically have to worry about this distinction.
diff --git a/noir_stdlib/src/cmp.nr b/noir_stdlib/src/cmp.nr
index ec979d60753..b7f473429a7 100644
--- a/noir_stdlib/src/cmp.nr
+++ b/noir_stdlib/src/cmp.nr
@@ -7,12 +7,14 @@ trait Eq {
 }
 // docs:end:eq-trait
 
+// docs:start:derive_eq
 comptime fn derive_eq(s: StructDefinition) -> Quoted {
     let signature = quote { fn eq(_self: Self, _other: Self) -> bool };
     let for_each_field = |name| quote { (_self.$name == _other.$name) };
     let body = |fields| fields;
     crate::meta::make_trait_impl(s, quote { Eq }, signature, for_each_field, quote { & }, body)
 }
+// docs:end:derive_eq
 
 impl Eq for Field { fn eq(self, other: Field) -> bool { self == other } }
 
@@ -118,6 +120,7 @@ trait Ord {
 }
 // docs:end:ord-trait
 
+// docs:start:derive_ord
 comptime fn derive_ord(s: StructDefinition) -> Quoted {
     let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };
     let for_each_field = |name| quote {
@@ -132,6 +135,7 @@ comptime fn derive_ord(s: StructDefinition) -> Quoted {
     };
     crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)
 }
+// docs:end:derive_ord
 
 // Note: Field deliberately does not implement Ord
 
diff --git a/noir_stdlib/src/hash/mod.nr b/noir_stdlib/src/hash/mod.nr
index d77b655398a..657e1cd8309 100644
--- a/noir_stdlib/src/hash/mod.nr
+++ b/noir_stdlib/src/hash/mod.nr
@@ -144,12 +144,14 @@ trait Hash {
     fn hash<H>(self, state: &mut H) where H: Hasher;
 }
 
+// docs:start:derive_hash
 comptime fn derive_hash(s: StructDefinition) -> Quoted {
     let name = quote { Hash };
     let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
     let for_each_field = |name| quote { _self.$name.hash(_state); };
     crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, |fields| fields)
 }
+// docs:end:derive_hash
 
 // Hasher trait shall be implemented by algorithms to provide hash-agnostic means.
 // TODO: consider making the types generic here ([u8], [Field], etc.)
diff --git a/noir_stdlib/src/meta/expr.nr b/noir_stdlib/src/meta/expr.nr
index aa9db196acd..718ba9607d4 100644
--- a/noir_stdlib/src/meta/expr.nr
+++ b/noir_stdlib/src/meta/expr.nr
@@ -4,64 +4,102 @@ use crate::meta::op::BinaryOp;
 
 impl Expr {
     #[builtin(expr_as_array)]
+    // docs:start:as_array
     fn as_array(self) -> Option<[Expr]> {}
+    // docs:end:as_array
 
     #[builtin(expr_as_integer)]
+    // docs:start:as_integer
     fn as_integer(self) -> Option<(Field, bool)> {}
+    // docs:end:as_integer
 
     #[builtin(expr_as_binary_op)]
+    // docs:start:as_binary_op
     fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+    // docs:end:as_binary_op
 
     #[builtin(expr_as_block)]
+    // docs:start:as_block
     fn as_block(self) -> Option<[Expr]> {}
+    // docs:end:as_block
 
     #[builtin(expr_as_bool)]
+    // docs:start:as_bool
     fn as_bool(self) -> Option<bool> {}
+    // docs:end:as_bool
 
     #[builtin(expr_as_cast)]
     fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
 
     #[builtin(expr_as_comptime)]
+    // docs:start:as_comptime
     fn as_comptime(self) -> Option<[Expr]> {}
+    // docs:end:as_comptime
 
     #[builtin(expr_as_function_call)]
+    // docs:start:as_function_call
     fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+    // docs:end:as_function_call
 
     #[builtin(expr_as_if)]
+    // docs:start:as_if
     fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+    // docs:end:as_if
 
     #[builtin(expr_as_index)]
+    // docs:start:as_index
     fn as_index(self) -> Option<(Expr, Expr)> {}
+    // docs:end:as_index
 
     #[builtin(expr_as_member_access)]
+    // docs:start:as_member_access
     fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+    // docs:end:as_member_access
 
     #[builtin(expr_as_repeated_element_array)]
+    // docs:start:as_repeated_element_array
     fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+    // docs:end:as_repeated_element_array
 
     #[builtin(expr_as_repeated_element_slice)]
+    // docs:start:as_repeated_element_slice
     fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+    // docs:end:as_repeated_element_slice
 
     #[builtin(expr_as_slice)]
+    // docs:start:as_slice
     fn as_slice(self) -> Option<[Expr]> {}
+    // docs:end:as_slice
 
     #[builtin(expr_as_tuple)]
+    // docs:start:as_tuple
     fn as_tuple(self) -> Option<[Expr]> {}
+    // docs:end:as_tuple
 
     #[builtin(expr_as_unary_op)]
+    // docs:start:as_unary_op
     fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+    // docs:end:as_unary_op
 
     #[builtin(expr_as_unsafe)]
+    // docs:start:as_unsafe
     fn as_unsafe(self) -> Option<[Expr]> {}
+    // docs:end:as_unsafe
 
     #[builtin(expr_has_semicolon)]
+    // docs:start:has_semicolon
     fn has_semicolon(self) -> bool {}
+    // docs:end:has_semicolon
 
     #[builtin(expr_is_break)]
+    // docs:start:is_break
     fn is_break(self) -> bool {}
+    // docs:end:is_break
 
     #[builtin(expr_is_continue)]
+    // docs:start:is_continue
     fn is_continue(self) -> bool {}
+    // docs:end:is_continue
 }
 
 mod tests {
@@ -120,8 +158,10 @@ mod tests {
             assert(get_binary_op(quote { x / y }).is_divide());
             assert(get_binary_op(quote { x == y }).is_equal());
             assert(get_binary_op(quote { x != y }).is_not_equal());
-            assert(get_binary_op(quote { x > y }).is_greater());
-            assert(get_binary_op(quote { x >= y }).is_greater_or_equal());
+            assert(get_binary_op(quote { x < y }).is_less_than());
+            assert(get_binary_op(quote { x <= y }).is_less_than_or_equal());
+            assert(get_binary_op(quote { x > y }).is_greater_than());
+            assert(get_binary_op(quote { x >= y }).is_greater_than_or_equal());
             assert(get_binary_op(quote { x & y }).is_and());
             assert(get_binary_op(quote { x | y }).is_or());
             assert(get_binary_op(quote { x ^ y }).is_xor());
@@ -176,6 +216,9 @@ mod tests {
         }
     }
 
+    // This test can't only be around the comptime block since that will cause
+    // `nargo fmt` to remove the comptime keyword.
+    // docs:start:as_expr_example
     #[test]
     fn test_expr_as_function_call() {
         comptime
@@ -186,6 +229,7 @@ mod tests {
             assert_eq(args[0].as_integer().unwrap(), (42, false));
         }
     }
+    // docs:end:as_expr_example
 
     #[test]
     fn test_expr_as_if() {
diff --git a/noir_stdlib/src/meta/function_def.nr b/noir_stdlib/src/meta/function_def.nr
index 2b5ddd008ea..7ac8803e7e4 100644
--- a/noir_stdlib/src/meta/function_def.nr
+++ b/noir_stdlib/src/meta/function_def.nr
@@ -1,19 +1,31 @@
 impl FunctionDefinition {
     #[builtin(function_def_name)]
+    // docs:start:name
     fn name(self) -> Quoted {}
+    // docs:end:name
 
     #[builtin(function_def_parameters)]
+    // docs:start:parameters
     fn parameters(self) -> [(Quoted, Type)] {}
+    // docs:end:parameters
 
     #[builtin(function_def_return_type)]
+    // docs:start:return_type
     fn return_type(self) -> Type {}
+    // docs:end:return_type
 
     #[builtin(function_def_set_body)]
+    // docs:start:set_body
     fn set_body(self, body: Quoted) {}
+    // docs:end:set_body
 
     #[builtin(function_def_set_parameters)]
+    // docs:start:set_parameters
     fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+    // docs:end:set_parameters
 
     #[builtin(function_def_set_return_type)]
+    // docs:start:set_return_type
     fn set_return_type(self, return_type: Type) {}
+    // docs:end:set_return_type
 }
diff --git a/noir_stdlib/src/meta/mod.nr b/noir_stdlib/src/meta/mod.nr
index 8c706e6c37b..1ace2d028a4 100644
--- a/noir_stdlib/src/meta/mod.nr
+++ b/noir_stdlib/src/meta/mod.nr
@@ -12,13 +12,17 @@ mod quoted;
 /// Calling unquote as a macro (via `unquote!(arg)`) will unquote
 /// its argument. Since this is the effect `!` already does, `unquote`
 /// itself does not need to do anything besides return its argument.
+// docs:start:unquote
 pub comptime fn unquote(code: Quoted) -> Quoted {
+    // docs:end:unquote
     code
 }
 
 /// Returns the type of any value
 #[builtin(type_of)]
+// docs:start:type_of
 pub comptime fn type_of<T>(x: T) -> Type {}
+// docs:end:type_of
 
 // docs:start:derive_example
 // These are needed for the unconstrained hashmap we're using to store derive functions
@@ -36,8 +40,10 @@ comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHas
 // Given a struct and a slice of traits to derive, create trait impls for each.
 // This function is as simple as iterating over the slice, checking if we have a trait
 // handler registered for the given trait, calling it, and appending the result.
+// docs:start:derive
 #[varargs]
 pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+    // docs:end:derive
     let mut result = quote {};
 
     for trait_to_derive in traits {
@@ -56,7 +62,9 @@ pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted
 
 // docs:start:derive_via
 // To register a handler for a trait, just add it to our handlers map
+// docs:start:derive_via_signature
 pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+    // docs:end:derive_via_signature
     HANDLERS.insert(t, f);
 }
 // docs:end:derive_via
@@ -73,6 +81,7 @@ pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
 /// any final processing - e.g. wrapping each field in a `StructConstructor { .. }` expression.
 ///
 /// See `derive_eq` and `derive_default` for example usage.
+// docs:start:make_trait_impl
 pub comptime fn make_trait_impl<Env1, Env2>(
     s: StructDefinition,
     trait_name: Quoted,
@@ -81,6 +90,7 @@ pub comptime fn make_trait_impl<Env1, Env2>(
     join_fields_with: Quoted,
     body: fn[Env2](Quoted) -> Quoted
 ) -> Quoted {
+    // docs:end:make_trait_impl
     let typ = s.as_type();
     let impl_generics = s.generics().map(|g| quote { $g }).join(quote {,});
     let where_clause = s.generics().map(|name| quote { $name: $trait_name }).join(quote {,});
diff --git a/noir_stdlib/src/meta/module.nr b/noir_stdlib/src/meta/module.nr
index ee00f360806..6ea3ca55fb1 100644
--- a/noir_stdlib/src/meta/module.nr
+++ b/noir_stdlib/src/meta/module.nr
@@ -1,10 +1,16 @@
 impl Module {
     #[builtin(module_is_contract)]
+// docs:start:is_contract
     fn is_contract(self) -> bool {}
+    // docs:end:is_contract
 
     #[builtin(module_functions)]
+// docs:start:functions
     fn functions(self) -> [FunctionDefinition] {}
+    // docs:end:functions
 
     #[builtin(module_name)]
+// docs:start:name
     fn name(self) -> Quoted {}
+    // docs:end:name
 }
diff --git a/noir_stdlib/src/meta/op.nr b/noir_stdlib/src/meta/op.nr
index ebd89677c50..9c892c4d80b 100644
--- a/noir_stdlib/src/meta/op.nr
+++ b/noir_stdlib/src/meta/op.nr
@@ -3,19 +3,27 @@ struct UnaryOp {
 }
 
 impl UnaryOp {
-    fn is_minus(self) -> bool {
+    // docs:start:is_minus
+    pub fn is_minus(self) -> bool {
+        // docs:end:is_minus
         self.op == 0
     }
 
-    fn is_not(self) -> bool {
+    // docs:start:is_not
+    pub fn is_not(self) -> bool {
+        // docs:end:is_not
         self.op == 1
     }
 
-    fn is_mutable_reference(self) -> bool {
+    // docs:start:is_mutable_reference
+    pub fn is_mutable_reference(self) -> bool {
+        // docs:end:is_mutable_reference
         self.op == 2
     }
 
-    fn is_dereference(self) -> bool {
+    // docs:start:is_dereference
+    pub fn is_dereference(self) -> bool {
+        // docs:end:is_dereference
         self.op == 3
     }
 }
@@ -25,67 +33,99 @@ struct BinaryOp {
 }
 
 impl BinaryOp {
-    fn is_add(self) -> bool {
+    // docs:start:is_add
+    pub fn is_add(self) -> bool {
+        // docs:end:is_add
         self.op == 0
     }
 
-    fn is_subtract(self) -> bool {
+    // docs:start:is_subtract
+    pub fn is_subtract(self) -> bool {
+        // docs:end:is_subtract
         self.op == 1
     }
 
-    fn is_multiply(self) -> bool {
+    // docs:start:is_multiply
+    pub fn is_multiply(self) -> bool {
+        // docs:end:is_multiply
         self.op == 2
     }
 
-    fn is_divide(self) -> bool {
+    // docs:start:is_divide
+    pub fn is_divide(self) -> bool {
+        // docs:end:is_divide
         self.op == 3
     }
 
-    fn is_equal(self) -> bool {
+    // docs:start:is_equal
+    pub fn is_equal(self) -> bool {
+        // docs:end:is_equal
         self.op == 4
     }
 
-    fn is_not_equal(self) -> bool {
+    // docs:start:is_not_equal
+    pub fn is_not_equal(self) -> bool {
+        // docs:end:is_not_equal
         self.op == 5
     }
 
-    fn is_less(self) -> bool {
+    // docs:start:is_less_than
+    pub fn is_less_than(self) -> bool {
+        // docs:end:is_less_than
         self.op == 6
     }
 
-    fn is_less_equal(self) -> bool {
+    // docs:start:is_less_than_or_equal
+    pub fn is_less_than_or_equal(self) -> bool {
+        // docs:end:is_less_than_or_equal
         self.op == 7
     }
 
-    fn is_greater(self) -> bool {
+    // docs:start:is_greater_than
+    pub fn is_greater_than(self) -> bool {
+        // docs:end:is_greater_than
         self.op == 8
     }
 
-    fn is_greater_or_equal(self) -> bool {
+    // docs:start:is_greater_than_or_equal
+    pub fn is_greater_than_or_equal(self) -> bool {
+        // docs:end:is_greater_than_or_equal
         self.op == 9
     }
 
-    fn is_and(self) -> bool {
+    // docs:start:is_and
+    pub fn is_and(self) -> bool {
+        // docs:end:is_and
         self.op == 10
     }
 
-    fn is_or(self) -> bool {
+    // docs:start:is_or
+    pub fn is_or(self) -> bool {
+        // docs:end:is_or
         self.op == 11
     }
 
-    fn is_xor(self) -> bool {
+    // docs:start:is_xor
+    pub fn is_xor(self) -> bool {
+        // docs:end:is_xor
         self.op == 12
     }
 
-    fn is_shift_right(self) -> bool {
+    // docs:start:is_shift_right
+    pub fn is_shift_right(self) -> bool {
+        // docs:end:is_shift_right
         self.op == 13
     }
 
-    fn is_shift_left(self) -> bool {
+    // docs:start:is_shift_left
+    pub fn is_shift_left(self) -> bool {
+        // docs:end:is_shift_left
         self.op == 14
     }
 
-    fn is_modulo(self) -> bool {
+    // docs:start:is_modulo
+    pub fn is_modulo(self) -> bool {
+        // docs:end:is_modulo
         self.op == 15
     }
 }
diff --git a/noir_stdlib/src/meta/quoted.nr b/noir_stdlib/src/meta/quoted.nr
index cccc3fe0f12..9fd1e9026ba 100644
--- a/noir_stdlib/src/meta/quoted.nr
+++ b/noir_stdlib/src/meta/quoted.nr
@@ -3,16 +3,24 @@ use crate::option::Option;
 
 impl Quoted {
     #[builtin(quoted_as_expr)]
+// docs:start:as_expr
     fn as_expr(self) -> Option<Expr> {}
+    // docs:end:as_expr
 
     #[builtin(quoted_as_module)]
+// docs:start:as_module
     fn as_module(self) -> Option<Module> {}
+    // docs:end:as_module
 
     #[builtin(quoted_as_trait_constraint)]
+// docs:start:as_trait_constraint
     fn as_trait_constraint(self) -> TraitConstraint {}
+    // docs:end:as_trait_constraint
 
     #[builtin(quoted_as_type)]
+// docs:start:as_type
     fn as_type(self) -> Type {}
+    // docs:end:as_type
 }
 
 impl Eq for Quoted {
diff --git a/noir_stdlib/src/meta/struct_def.nr b/noir_stdlib/src/meta/struct_def.nr
index 8d3f9ceb8a5..60fdeba21aa 100644
--- a/noir_stdlib/src/meta/struct_def.nr
+++ b/noir_stdlib/src/meta/struct_def.nr
@@ -2,14 +2,20 @@ impl StructDefinition {
     /// Return a syntactic version of this struct definition as a type.
     /// For example, `as_type(quote { type Foo<A, B> { ... } })` would return `Foo<A, B>`
     #[builtin(struct_def_as_type)]
+// docs:start:as_type
     fn as_type(self) -> Type {}
+    // docs:end:as_type
 
     /// Return each generic on this struct.
     #[builtin(struct_def_generics)]
+// docs:start:generics
     fn generics(self) -> [Type] {}
+    // docs:end:generics
 
     /// Returns (name, type) pairs of each field in this struct. Each type is as-is
     /// with any generic arguments unchanged.
     #[builtin(struct_def_fields)]
+// docs:start:fields
     fn fields(self) -> [(Quoted, Type)] {}
+    // docs:end:fields
 }
diff --git a/noir_stdlib/src/meta/trait_def.nr b/noir_stdlib/src/meta/trait_def.nr
index ca381cb8e16..c26b571240b 100644
--- a/noir_stdlib/src/meta/trait_def.nr
+++ b/noir_stdlib/src/meta/trait_def.nr
@@ -3,7 +3,9 @@ use crate::cmp::Eq;
 
 impl TraitDefinition {
     #[builtin(trait_def_as_trait_constraint)]
+// docs:start:as_trait_constraint
     fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+    // docs:end:as_trait_constraint
 }
 
 impl Eq for TraitDefinition {
diff --git a/noir_stdlib/src/meta/trait_impl.nr b/noir_stdlib/src/meta/trait_impl.nr
index 2f82ee5f434..15b02eac6bd 100644
--- a/noir_stdlib/src/meta/trait_impl.nr
+++ b/noir_stdlib/src/meta/trait_impl.nr
@@ -1,7 +1,11 @@
 impl TraitImpl {
     #[builtin(trait_impl_trait_generic_args)]
+// docs:start:trait_generic_args
     fn trait_generic_args(self) -> [Type] {}
+    // docs:end:trait_generic_args
 
     #[builtin(trait_impl_methods)]
+// docs:start:methods
     fn methods(self) -> [FunctionDefinition] {}
+    // docs:end:methods
 }
diff --git a/noir_stdlib/src/meta/typ.nr b/noir_stdlib/src/meta/typ.nr
index 67ad2a96739..a3f35b28e43 100644
--- a/noir_stdlib/src/meta/typ.nr
+++ b/noir_stdlib/src/meta/typ.nr
@@ -3,34 +3,54 @@ use crate::option::Option;
 
 impl Type {
     #[builtin(type_as_array)]
+// docs:start:as_array
     fn as_array(self) -> Option<(Type, Type)> {}
+    // docs:end:as_array
 
     #[builtin(type_as_constant)]
+// docs:start:as_constant
     fn as_constant(self) -> Option<u32> {}
+    // docs:end:as_constant
 
     #[builtin(type_as_integer)]
+// docs:start:as_integer
     fn as_integer(self) -> Option<(bool, u8)> {}
+    // docs:end:as_integer
 
     #[builtin(type_as_slice)]
+// docs:start:as_slice
     fn as_slice(self) -> Option<Type> {}
+    // docs:end:as_slice
 
     #[builtin(type_as_struct)]
+// docs:start:as_struct
     fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+    // docs:end:as_struct
 
     #[builtin(type_as_tuple)]
+// docs:start:as_tuple
     fn as_tuple(self) -> Option<[Type]> {}
+    // docs:end:as_tuple
 
     #[builtin(type_get_trait_impl)]
+// docs:start:get_trait_impl
     fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+    // docs:end:get_trait_impl
 
     #[builtin(type_implements)]
+// docs:start:implements
     fn implements(self, constraint: TraitConstraint) -> bool {}
+    // docs:end:implements
 
     #[builtin(type_is_bool)]
+// docs:start:is_bool
     fn is_bool(self) -> bool {}
+    // docs:end:is_bool
 
     #[builtin(type_is_field)]
+// docs:start:is_field
     fn is_field(self) -> bool {}
+    // docs:end:is_field
 }
 
 impl Eq for Type {
diff --git a/test_programs/compile_success_empty/comptime_module/src/main.nr b/test_programs/compile_success_empty/comptime_module/src/main.nr
index e9c9817cfd8..8d834381fea 100644
--- a/test_programs/compile_success_empty/comptime_module/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_module/src/main.nr
@@ -24,3 +24,18 @@ fn main() {
         assert_eq(bar.name(), quote { bar });
     }
 }
+
+// docs:start:as_module_example
+mod baz {
+    mod qux {}
+}
+
+#[test]
+fn as_module_test() {
+    comptime
+    {
+        let my_mod = quote { baz::qux }.as_module().unwrap();
+        assert_eq(my_mod.name(), quote { qux });
+    }
+}
+// docs:end:as_module_example
diff --git a/test_programs/compile_success_empty/comptime_type/src/main.nr b/test_programs/compile_success_empty/comptime_type/src/main.nr
index f0b53a392ed..6d98d1d173b 100644
--- a/test_programs/compile_success_empty/comptime_type/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_type/src/main.nr
@@ -113,6 +113,7 @@ fn main() {
     }
 }
 
+// docs:start:implements_example
 fn function_with_where<T>(_x: T) where T: SomeTrait<i32> {
     comptime
     {
@@ -123,3 +124,4 @@ fn function_with_where<T>(_x: T) where T: SomeTrait<i32> {
         assert(t.get_trait_impl(some_trait_i32).is_none());
     }
 }
+// docs:end:implements_example