diff --git a/Makefile b/Makefile
index 738caf6c7..e0f79b0d8 100644
--- a/Makefile
+++ b/Makefile
@@ -36,3 +36,7 @@ bench:
.PHONY: default install uninstall reinstall clean test doc bench
.PHONY: all-supported-ocaml-versions opam-release
+
+.PHONY: $(TARGET)
+example-%:
+ DUNE_CONFIG__GLOBAL_LOCK=disabled opam exec -- dune exec $*-example
diff --git a/doc/dune b/doc/dune
index 8942dccc3..aad6f3b77 100644
--- a/doc/dune
+++ b/doc/dune
@@ -1,2 +1,12 @@
(documentation
(package ppxlib))
+
+(rule
+ (alias doc)
+ (deps
+ (glob_files ./images/*))
+ (action
+ (progn
+ (system "echo 'hello'")
+ (system "mkdir -p %{project_root}/_doc/_html/ppxlib/assets/images")
+ (system "cp -R ./images/ %{project_root}/_doc/_html/ppxlib/assets/images/"))))
diff --git a/doc/example-ast copy.mld b/doc/example-ast copy.mld
new file mode 100644
index 000000000..cf34f20c0
--- /dev/null
+++ b/doc/example-ast copy.mld
@@ -0,0 +1,407 @@
+{0 Abstract Syntax Tree (AST)}
+
+{1 Table of Contents}
+
+- {{!section-description} Description}
+- {{!section-"preprocessing-in-ocaml"} Preprocessing in OCaml}
+- {{!section-"ast-guide"} AST Guide}
+- {{!section-"why-should-i-understand-the-ast"} Why Should I Understand the AST?}
+- {{!section-"first-look"} First Look}
+- {{!section-"structure"} Structure}
+- {{!section-"language-extensions-and-attributes"} Language Extensions and Attributes}
+- {{!section-"samples"} Samples}
+
+{1 Description}
+
+The Abstract Syntax Tree (AST) is a critical component in the OCaml compilation process. It represents the structure of the source code in a tree-like format, allowing for advanced code manipulations and transformations. This guide explores the importance of the AST, how it is used in preprocessing, and the different methods available for working with it through {b PPX} (PreProcessor eXtensions).
+
+{1:preprocessing-in-ocaml Preprocessing in OCaml}
+
+Unlike some programming languages that have built-in preprocessing features—such as C's preprocessor or Rust's macro system, OCaml lacks an integrated macro system. Instead, it relies on standalone preprocessors.
+
+The OCaml Platform officially supports a library for creating these preprocessors, which can operate at two levels:
+
+- {b Source Level}: Preprocessors work directly on the source code.
+- {b AST Level}: Preprocessors manipulate the AST, offering more powerful and flexible transformations. (Covered in this guide)
+
+{%html:
+
+
⚠️ WARNING
+
One of the key challenges with working with the Parsetree (the AST in OCaml) is that its API is not stable. For instance, in the OCaml 4.13 release, significant changes were made to the Parsetree type, which can impact the compatibility of your preprocessing tools. Read more about it in The Future of PPX.
+
+
💡 Tip
+
Every module in OCaml creates a new structure, and nested modules create nested structures.
+
+
✏️ Note
+
A structure item can either represent a top-level expression, a type definition, a let definition, etc.
+
+
✏️ Note
+
In the code let name = [%name "John Doe"], [%name "John Doe"] is the extension node, where name is the extension name string Ast_414.Asttypes.loc and "John Doe" is the payload. For the entire item like let name = "John Doe", you must use %%: [%%name "John Doe"].
+
+
+
+
+ | Playground |
+ Code |
+ AST |
+
+
+ | Link |
+
+ 1 |let name = "john doe"
+ |
+
+ 1 |[
+2 | {
+3 | Pstr_value: [ (* ... *) ];
+4 | }
+5 |]
+ |
+
+
+ | Link |
+
+ 1 | module GameEnum = struct
+2 | type t = Rock | Paper | Scissors
+3 | let to_string = function
+4 | | Rock -> "Rock"
+5 | | Paper -> "Paper"
+6 | | Scissors -> "Scissors"
+7 | let from_string = function
+8 | | "Rock" -> Rock
+9 | | "Paper" -> Paper
+10| | "Scissors" -> Scissors
+11| | _ -> failwith "Invalid string"
+12| end
+ |
+
+ 1 |[
+2 | Pstr_module
+3 | { pmb_name = {
+4 | txt = Some "GameEnum"
+5 | loc = { (* ... *) }
+6 | };
+7 | pmb_expr = {
+8 | pmod_desc = Pmod_structure [ (* ... *) ]
+9 | pmod_loc = { (* ... *) }
+10| pmod_loc_stack = []
+11| pmod_attributes = []
+12| };
+13| pmb_attributes = [];
+14| pmb_loc = { (* ... *) }
+15| }
+16|]
+ |
+
+
+ | Link |
+  |
+  |
+
+
+ | Link |
+ ![Code `let name = [%name "John Doe"]` with `[%name "John Doe"]` highlighted](./assets/images/extension_node.png) |
+  |
+
+
+ | Link |
+ ![Code `let name = [%name "John Doe"]` with `name` highlighted](./assets/images/extension_node_name.png) |
+  |
+
+
+ | Link |
+ ![Code `let name = [%name "John Doe"]` with `"John Doe"` highlighted](./assets/images/extension_node_payload.png) |
+  |
+
+
+ | Link |
+ ![Code `let name = "John Doe" [@print expr]` with `print` highlighted](./assets/images/attribute_name.png) |
+  |
+
+
+ | Link |
+ ![Code `let name = "John Doe" [@print expr]` with `expr` highlighted](./assets/images/attribute_payload.png) |
+  |
+
+
+ | Link |
+  |
+  |
+
+
+ | Link |
+  |
+  |
+
+
+ | Link |
+  |
+  |
+
+
+%}
+
+{1 Next Steps}
+On the next section, we will learn how to build an AST. {{:./a%20-%20Building%20AST/README.md} Read more}
diff --git a/doc/example-ast-building.mld b/doc/example-ast-building.mld
new file mode 100644
index 000000000..bc4d3c918
--- /dev/null
+++ b/doc/example-ast-building.mld
@@ -0,0 +1,173 @@
+{0 Building AST}
+
+{1 Table of Contents}
+
+- {{!section-description} Description}
+- {{!section-"building-asts-with-pure-ocaml"} Building ASTs with Pure OCaml}
+{ul {- {{!section-"example-building-a-simple-integer-ast-manually"} Example: Building a Simple Integer AST Manually}}}
+
+- {{!section-"building-asts-with-ast_builder"} Building ASTs with `AST_builder`}
+{ul {- {{!section-"example-1-using-pexp_constant-for-integer-ast"} Example 1: Using `pexp_constant` for Integer AST}}}
+{ul {- {{!section-"example-2-using-eint-for-simplified-integer-ast"} Example 2: Using `eint` for Simplified Integer AST}}}
+
+- {{!section-"using-metaquot-for-ast-construction"} Using Metaquot for AST Construction}
+{ul {- {{!section-"example-building-an-integer-ast-with-metaquot"} Example: Building an Integer AST with Metaquot}}}
+
+- {{!section-"using-anti-quotations-in-metaquot"} Using Anti-Quotations in Metaquot}
+{ul {- {{!section-"example-inserting-dynamic-expressions-with-anti-quotations"} Example: Inserting Dynamic Expressions with Anti-Quotations}}}
+
+- {{!section-"building-complex-expressions"} Building Complex Expressions}
+{ul {- {{!section-"example-1-constructing-a-let-expression-with-ast_builder"} Example 1: Constructing a Let Expression with `AST_builder`}}}
+{ul {- {{!section-"example-2-constructing-a-let-expression-with-metaquot"} Example 2: Constructing a Let Expression with Metaquot}}}
+
+- {{!section-conclusion} Conclusion}
+
+{1:description Description}
+
+Building an AST (Abstract Syntax Tree) is a fundamental part of creating a PPX in OCaml. You'll need to construct an AST to represent the code you want to generate or transform.
+
+For example, if you want to generate the following code:
+
+{[
+let zero = [%int 0]
+]}
+
+and replace the extension point `[%int 0]` with `0` to produce `let zero = 0`, you’ll need to build an AST that represents this transformation.
+
+There are several methods to build an AST. We’ll discuss three approaches:
+
+- {b Building ASTs with Pure OCaml}
+- {b Building ASTs with `AST_builder`}
+- {b Using Metaquot for AST Construction}
+
+{1:building-asts-with-pure-ocaml Building ASTs with Low-Level Builders}
+
+The most fundamental way to build an AST is to manually construct it using Low-Level Builders data structures.
+
+{2:example-building-a-simple-integer-ast-manually Example: Building a Simple Integer AST Manually}
+
+{{:https://github.com/ocaml-ppx/ppxlib/tree/main/examples/1-AST/a%20-%20Building%20AST/building_ast.ml#L5-L16} 🔗 Sample Code}
+
+{[
+let zero ~loc : Ppxlib_ast.Ast.expression =
+ {
+ pexp_desc = Pexp_constant (Pconst_integer ("0", None));
+ pexp_loc = loc;
+ pexp_loc_stack = [];
+ pexp_attributes = [];
+ }
+]}
+
+While this method provides full control over the AST, it is verbose and less maintainable.
+
+{1:building-asts-with-ast_builder Building ASTs with `AST_builder`}
+
+PPXLib provides the `AST_builder` module, which simplifies the process of building ASTs by providing helper functions.
+
+{2:example-1-using-pexp_constant-for-integer-ast Example 1: Using `pexp_constant` for Integer AST}
+
+{{:https://github.com/ocaml-ppx/ppxlib/tree/main/examples/1-AST/a%20-%20Building%20AST/building_ast.ml#L18-L24} 🔗 Sample Code}
+
+{[
+let one ~loc =
+ Ast_builder.Default.pexp_constant ~loc (Parsetree.Pconst_integer ("1", None))
+]}
+
+This method is more readable and concise compared to the pure OCaml approach.
+
+{2:example-2-using-eint-for-simplified-integer-ast Example 2: Using `eint` for Simplified Integer AST}
+
+{{:https://github.com/ocaml-ppx/ppxlib/tree/main/examples/1-AST/a%20-%20Building%20AST/building_ast.ml#L26-L31} 🔗 Sample Code}
+
+{[
+let two ~loc = Ast_builder.Default.eint ~loc 2
+]}
+
+{b Tip:} `eint` is an abbreviation for expression (`e`) integer (`int`).
+
+{1:using-metaquot-for-ast-construction Using Metaquot for AST Construction}
+
+Metaquot is a syntax extension that allows you to write ASTs in a more natural and readable way.
+
+{2:example-building-an-integer-ast-with-metaquot Example: Building an Integer AST with Metaquot}
+
+{{:https://github.com/ocaml-ppx/ppxlib/tree/main/examples/1-AST/a%20-%20Building%20AST/building_ast.ml#L33-L38} 🔗 Sample Code}
+
+{[
+let three ~loc = [%expr 3]
+]}
+
+{b Tip:} Metaquot is highly readable and intuitive but is static. For dynamic values, use Anti-Quotations.
+
+{2:using-anti-quotations-in-metaquot Using Anti-Quotations in Metaquot}
+
+Anti-Quotations allow you to insert dynamic expressions into your Metaquot ASTs.
+
+{3:example-inserting-dynamic-expressions-with-anti-quotations Example: Inserting Dynamic Expressions with Anti-Quotations}
+
+{{:https://github.com/ocaml-ppx/ppxlib/tree/main/examples/1-AST/a%20-%20Building%20AST/building_ast.ml#L72-L77} 🔗 Sample Code}
+
+{[
+let anti_quotation_expr expr = [%expr 1 + [%e expr]]
+]}
+
+For example, to insert the AST for `1`:
+
+{[
+let _ =
+ print_endline
+ ("\nLet expression with metaquot and anti-quotation: "
+ ^ Astlib.Pprintast.string_of_expression (anti_quotation_expr (one ~loc)))
+]}
+
+{1:building-complex-expressions Building Complex Expressions}
+
+Beyond simple expressions, you may need to build more complex ASTs, such as `let` expressions.
+
+{2:example-1-constructing-a-let-expression-with-ast_builder Example 1: Constructing a Let Expression with `AST_builder`}
+
+{{:https://github.com/ocaml-ppx/ppxlib/tree/main/examples/1-AST/a%20-%20Building%20AST/building_ast.ml#L40-L60} 🔗 Sample Code}
+
+{[
+let let_expression =
+ let expression =
+ Ast_builder.Default.pexp_constant ~loc:Location.none
+ (Pconst_integer ("3", None))
+ in
+ let pattern =
+ Ast_builder.Default.ppat_var ~loc:Location.none
+ (Ast_builder.Default.Located.mk ~loc:Location.none "foo")
+ in
+ let let_binding =
+ Ast_builder.Default.value_binding ~loc:Location.none ~pat:pattern
+ ~expr:expression
+ in
+ Ast_builder.Default.pexp_let ~loc:Location.none Nonrecursive [ let_binding ]
+ (Ast_builder.Default.eunit ~loc:Location.none)
+]}
+
+{2:example-2-constructing-a-let-expression-with-metaquot Example 2: Constructing a Let Expression with Metaquot}
+
+{{:https://github.com/ocaml-ppx/ppxlib/tree/main/examples/1-AST/a%20-%20Building%20AST/building_ast.ml#L62-L70} 🔗 Sample Code}
+
+{[
+let let_expression =
+ [%expr
+ let foo = 3 in
+ ()]
+]}
+
+This approach is shorter and easier to understand.
+
+{1:conclusion Conclusion}
+
+In this section, we explored three methods for building ASTs:
+
+- {b Pure OCaml}: The most basic but verbose approach.
+- {b Using `AST_builder`}: A more readable and maintainable option.
+- {b Using Metaquot}: The most intuitive method, especially when combined with Anti-Quotations for dynamic values.
+
+Each method has its strengths, so choose the one that best fits your needs. Understanding all three will give you greater flexibility in creating effective and maintainable PPXs.
+
+{2 Next Steps}
+On the next section, we will learn how to destructure an AST. {{:../b%20-%20Destructing%20AST/README.md} Read more}
diff --git a/doc/example-ast-destructing.mld b/doc/example-ast-destructing.mld
new file mode 100644
index 000000000..8293aad36
--- /dev/null
+++ b/doc/example-ast-destructing.mld
@@ -0,0 +1,171 @@
+{0 Destructuring AST}
+
+{1:table-of-contents Table of Contents}
+
+- {{!section-description} Description}
+- {{!section-"ast-structure-pattern-matching"} AST Structure Pattern Matching}
+{ul {- {{!section-"example-matching-integer-payload-manually"} Example: Matching Integer Payload Manually}}}
+
+- {{!section-"using-ast_pattern-high-level-destructors"} Using `Ast_pattern` High-Level Destructors}
+{ul {- {{!section-"example-1-matching-integer-payload-with-ast_pattern"} Example 1: Matching Integer Payload with `Ast_pattern`}}}
+{ul {- {{!section-"example-2-simplifying-matching-with-eint"} Example 2: Simplifying Matching with `eint`}}}
+
+- {{!section-"using-metaquot"} Using Metaquot}
+{ul {- {{!section-"example-1-matching-integer-payload-with-metaquot"} Example 1: Matching Integer Payload with Metaquot}}}
+{ul {- {{!section-"example-2-matching-complex-expressions-with-metaquot-and-anti-quotations"} Example 2: Matching Complex Expressions with Metaquot and Anti-Quotations}}}
+
+- {{!section-"conclusion"} Conclusion}
+
+{1:description Description}
+
+Destructuring an AST (Abstract Syntax Tree) is essential when creating a PPX (preprocessor extension) in OCaml. To generate or transform code, you must first break down the AST to understand and manipulate its structure.
+
+For example, if you want to transform this code:
+
+{[
+let one = [%one]
+]}
+
+into:
+
+{[
+let one = 1
+]}
+
+You’ll need to destructure the AST representing the extension point (`[%one]`) to replace it with `1`.
+There are several ways to destructure an AST. We’ll explore three methods:
+
+- {b AST Structure Pattern Matching}
+- {b Using `Ast_pattern` High-Level Destructors}
+- {b Using Metaquot}
+
+{1:ast-structure-pattern-matching AST Structure Pattern Matching}
+
+The most fundamental method for destructuring an AST in PPXLib is by directly matching on the AST’s structure.
+
+{2:example-matching-integer-payload-manually Example: Matching Integer Payload Manually}
+
+{[:link: Sample Code](./destructuring_ast.ml#L11-L26)}
+
+Let’s say we want to destructure an AST representing the integer `1`:
+
+{[
+let match_int_payload ~loc payload =
+ match payload with
+ | PStr
+ [
+ {
+ pstr_desc =
+ Pstr_eval
+ ({ pexp_desc = Pexp_constant (Pconst_integer (value, None)); _ }, _);
+ _;
+ };
+ ] -> (
+ try Ok (value |> int_of_string)
+ with Failure _ ->
+ Error (Location.Error.createf ~loc "Value is not a valid integer"))
+ | _ -> Error (Location.Error.createf ~loc "Wrong pattern")
+]}
+
+1. {b Pattern Matching the Payload}:
+ - Begins by matching the `payload` with the expected structure.
+ - The pattern expects a structure (`PStr`) containing a single item.
+2. {b Destructuring the Structure Item}:
+ - Matches the `pstr_desc` field, expecting an evaluated expression (`Pstr_eval`).
+ - The expression should be a constant integer (`Pexp_constant` with `Pconst_integer`).
+ - Captures the integer value as a string in `value`.
+3. {b Handling the Matched Value}:
+ - Converts the `value` to an integer and returns `Ok` if successful.
+ - If conversion fails, returns an error message.
+4. {b Handling Mismatched Patterns}:
+ - If the `payload` doesn’t match the expected structure, it returns an error.
+
+While this method is powerful, it can be verbose and difficult to maintain as patterns become more complex.
+
+{1:using-ast_pattern-high-level-destructors Using `Ast_pattern` High-Level Destructors}
+
+To make AST destructuring more readable, PPXLib provides the `Ast_pattern` module, which offers high-level destructors.
+
+{2:example-1-matching-integer-payload-with-ast_pattern Example 1: Matching Integer Payload with `Ast_pattern`}
+
+{[:link: Sample Code](./destructuring_ast.ml#L37-L40)}
+
+Let’s destructure the same integer `1` AST using `Ast_pattern`:
+
+{[
+open Ppxlib
+
+let match_int_payload =
+ let open Ast_pattern in
+ pstr (pstr_eval (pexp_constant (pconst_integer (string "1") none)) nil ^:: nil)
+]}
+
+This code achieves the same result as the previous example but in a more concise and readable way.
+
+- {b `PStr`} becomes `pstr`
+- {b `Pstr_eval`} becomes `pstr_eval`
+- {b `Pexp_constant`} becomes `pexp_constant`
+- {b `Pconst_integer`} becomes `pconst_integer`
+
+{2:example-2-simplifying-matching-with-eint Example 2: Simplifying Matching with `eint`}
+
+{[:link: Sample Code](./destructuring_ast.ml#L40-L49)}
+
+You can further simplify it:
+
+{[
+let match_int_payload =
+ let open Ast_pattern in
+ pstr (pstr_eval (eint (int 1)) nil ^:: nil)
+]}
+
+Using `eint` instead of `pexp_constant` and `pconst_integer` provides better type safety. The `int` wildcard captures the integer value.
+
+{1:using-metaquot Using Metaquot}
+
+Metaquot is a syntax extension that allows you to write and destructure ASTs more intuitively.
+
+{2:example-1-matching-integer-payload-with-metaquot Example 1: Matching Integer Payload with Metaquot}
+
+{[:link: Sample Code](./destructuring_ast.ml#L51-L60)}
+
+Let’s destructure the same integer `1` AST with Metaquot:
+
+{[
+let match_int_payload expr =
+ match expr with
+ | [%expr 1] -> Ok 1
+ | _ -> Error (Location.Error.createf ~loc:expr.pexp_loc "Wrong pattern")
+]}
+
+{2:example-2-matching-complex-expressions-with-metaquot-and-anti-quotations Example 2: Matching Complex Expressions with Metaquot and Anti-Quotations}
+
+{[:link: Sample Code](./destructuring_ast.ml#L79-L90)}
+
+For example, to match any expression of the form `1 + `:
+
+{[
+let match_int_payload expr =
+ match expr with
+ | [%expr 1 + [%e? e]] -> (
+ match e with
+ | { pexp_desc = Pexp_constant (Pconst_integer (value, None)); _ } ->
+ Ok (1 + int_of_string value)
+ | _ -> Error (Location.Error.createf ~loc:e.pexp_loc "Invalid integer"))
+ | _ -> Error (Location.Error.createf ~loc:expr.pexp_loc "Wrong pattern")
+]}
+
+Metaquot simplifies the process, making the AST patterns more readable, especially for complex structures.
+
+{1:conclusion Conclusion}
+
+In this section, we explored different methods to destructure an AST using PPXLib:
+
+- {b AST Structure Pattern Matching}: Powerful but verbose.
+- {b Using `Ast_pattern` High-Level Destructors}: More readable and maintainable.
+- {b Using Metaquot}: Intuitive and effective for both simple and complex patterns.
+
+There’s no right way to destructure an AST, choose the approach that best fits your use case. Understanding all these methods is valuable for creating robust and maintainable PPXs.
+
+{1:next-steps Next Steps}
+On the next section, we will learn how to write a PPX. {{:../../2%20-%20Writing%20PPXs/README.md} Read more}
\ No newline at end of file
diff --git a/doc/example-ast.mld b/doc/example-ast.mld
new file mode 100644
index 000000000..e6f08fa02
--- /dev/null
+++ b/doc/example-ast.mld
@@ -0,0 +1,312 @@
+{0 Abstract Syntax Tree (AST)}
+
+{1 Table of Contents}
+
+- {{!section-description} Description}
+- {{!section-"preprocessing-in-ocaml"} Preprocessing in OCaml}
+- {{!section-"ast-guide"} AST Guide}
+- {{!section-"why-should-i-understand-the-ast"} Why Should I Understand the AST?}
+- {{!section-"first-look"} First Look}
+- {{!section-"structure"} Structure}
+- {{!section-"language-extensions-and-attributes"} Language Extensions and Attributes}
+- {{!section-"samples"} Samples}
+
+{1 Description}
+
+The Abstract Syntax Tree (AST) is a critical component in the OCaml compilation process. It represents the structure of the source code in a tree-like format, allowing for advanced code manipulations and transformations. This guide explores the importance of the AST, how it is used in preprocessing, and the different methods available for working with it through {b PPX} (PreProcessor eXtensions).
+
+{1:preprocessing-in-ocaml Preprocessing in OCaml}
+
+Unlike some programming languages that have built-in preprocessing features—such as C's preprocessor or Rust's macro system, OCaml lacks an integrated macro system. Instead, it relies on standalone preprocessors.
+
+The OCaml Platform officially supports a library for creating these preprocessors, which can operate at two levels:
+
+- {b Source Level}: Preprocessors work directly on the source code.
+- {b AST Level}: Preprocessors manipulate the AST, offering more powerful and flexible transformations. (Covered in this guide)
+
+{%html:
+
+
⚠️ WARNING
+
One of the key challenges with working with the Parsetree (the AST in OCaml) is that its API is not stable. For instance, in the OCaml 4.13 release, significant changes were made to the Parsetree type, which can impact the compatibility of your preprocessing tools. Read more about it in The Future of PPX.
+
+
💡 Tip
+
Every module in OCaml creates a new structure, and nested modules create nested structures.
+
+
✏️ Note
+
A structure item can either represent a top-level expression, a type definition, a let definition, etc.
+
+
✏️ Note
+
In the code let name = [%name "John Doe"], [%name "John Doe"] is the extension node, where name is the extension name string Ast_414.Asttypes.loc and "John Doe" is the payload. For the entire item like let name = "John Doe", you must use %%: [%%name "John Doe"].
+
+
%} | {%html:
%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/1d56a1d5b20fc0a55d5ae9d309226dce58f93d2c} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/4002362a8c42e1c4f28790f54682a9cb4fc07a85} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/4002362a8c42e1c4f28790f54682a9cb4fc07a85} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/4002362a8c42e1c4f28790f54682a9cb4fc07a85} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/b4492b3d2d1b34029d367ff278f5bcda0496c0d2} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/b4492b3d2d1b34029d367ff278f5bcda0496c0d2} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/27d0a140f268bae1a32c8882d55c0b26c7e03fe9} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/27d0a140f268bae1a32c8882d55c0b26c7e03fe9} Link} | {%html:%} | {%html:%} |
+ | {{:https://astexplorer.net/#/gist/d479d32127d6fcb418622ee84b9aa3b2/27d0a140f268bae1a32c8882d55c0b26c7e03fe9} Link} | {%html:%} | {%html:%} |
+}
+
+{1 Next Steps}
+On the next section, we will learn how to build an AST. {{:./a%20-%20Building%20AST/README.md} Read more}
diff --git a/doc/examples.mld b/doc/examples.mld
index ca72780ea..34769c106 100644
--- a/doc/examples.mld
+++ b/doc/examples.mld
@@ -1,167 +1,22 @@
-{%html: %}{{!"good-practices"}< Good practices}{%html:
%}{%html:
%}{{!"good-practices"}< Good practices}{%html:
%}{%html: