Do not use @example in code chunks

Author: AleMorales

docs/src/tutorials/algae.md

@@ -18,7 +18,7 @@ Lindermayer as one of the first L-systems.
 First, we need to load the VPL metapackage, which will automatically load all
 the packages in the VPL ecosystem.
 
-````@example algae
+````julia
 using VirtualPlantLab
 ````
 
@@ -36,7 +36,7 @@ include type definitions in a module to avoid having to restart the Julia
 session whenever we want to redefine them. Because each module is an independent
 namespace, we need to import `Node` from the VPL package inside the module:
 
-````@example algae
+````julia
 module algae
     import VirtualPlantLab: Node
     struct A <: Node end
@@ -50,7 +50,7 @@ the nodes, so types `A` and `B` do not require fields.
 
 The axiom is simply defined as an instance of type of `A`:
 
-````@example algae
+````julia
 axiom = algae.A()
 ````
 
@@ -77,7 +77,7 @@ relationship between two nodes and `[]` indicates branching.
 
 The implementation of the two rules of algae growth model in VPL is as follows:
 
-````@example algae
+````julia
 rule1 = Rule(algae.A, rhs = x -> algae.A() + algae.B())
 rule2 = Rule(algae.B, rhs = x -> algae.A())
 ````
@@ -87,7 +87,7 @@ Note that in each case, the argument `rhs` is being assigned an anonymous (aka
 in the assigment to the argument. That is, the Julia expression `x -> A() + B()`
 is equivalent to the following function definition:
 
-````@example algae
+````julia
 function rule_1(x)
     algae.A() + algae.B()
 end
@@ -103,15 +103,15 @@ With the axiom and rules we can now create a `Graph` object that represents the
 algae organism. The first argument is the axiom and the second is a tuple with
 all the rewriting rules:
 
-````@example algae
+````julia
 organism = Graph(axiom = axiom, rules = (rule1, rule2))
 ````
 
 If we apply the rewriting rules iteratively, the graph will grow, in this case
 representing the growth of the algae organism. The rewriting rules are applied
 on the graph with the function `rewrite!()`:
 
-````@example algae
+````julia
 rewrite!(organism)
 ````
 
@@ -125,7 +125,7 @@ interactive version of the graph will be drawn and one can zoom and pan with the
 mouse (in this online document a static version is shown, see
 [Backends](../manual/Visualization.md) for details):
 
-````@example algae
+````julia
 import GLMakie
 draw(organism)
 ````
@@ -137,15 +137,15 @@ purposes (this will be explained in more advanced examples).
 
 Applying multiple iterations of rewriting can be achieved with a simple loop:
 
-````@example algae
+````julia
 for i in 1:4
     rewrite!(organism)
 end
 ````
 
 And we can verify that the graph grew as expected:
 
-````@example algae
+````julia
 draw(organism)
 ````
 

docs/src/tutorials/context.md

@@ -34,7 +34,7 @@ parent node that was captured. Note that that now, the rhs component gets a new
 argument, which corresponds to the context of the father node captured in the
 lhs.
 
-````@example context
+````julia
 using VirtualPlantLab
 module types
     using VirtualPlantLab
@@ -63,21 +63,21 @@ all the `Cell` nodes. A `Query` object is created by passing the type of the
 node to be queried as an argument to the `Query` function. Then, to actually
 execute the query we need to use the `apply` function on the graph.
 
-````@example context
+````julia
 getCell = Query(Cell)
 apply(pop, getCell)
 ````
 
 If we rewrite the graph one we will see that a second cell now has a state of 1.
 
-````@example context
+````julia
 rewrite!(pop)
 apply(pop, getCell)
 ````
 
 And a second iteration results in all cells have a state of 1
 
-````@example context
+````julia
 rewrite!(pop)
 apply(pop, getCell)
 ````
@@ -93,7 +93,7 @@ the `state` of each node in a vector (unlike Rules and Queries, this function
 takes the actual node as argument rather than a `Context` object, see the
 documentation for more details):
 
-````@example context
+````julia
 pop  = Graph(axiom = axiom, rules = rule)
 states = Int64[]
 traverse_dfs(pop, fun = node -> push!(states, node.state))
@@ -102,7 +102,7 @@ states
 
 Now the states of the nodes are in the same order as they were created:
 
-````@example context
+````julia
 rewrite!(pop)
 states = Int64[]
 traverse_dfs(pop, fun = node -> push!(states, node.state))

docs/src/tutorials/forest.md

@@ -14,7 +14,7 @@ growth of these trees vary across individuals following a predefined distributio
 The data types, rendering methods and growth rules are the same as in the binary
 tree example:
 
-````@example forest
+````julia
 using VirtualPlantLab
 using Distributions, Plots, ColorTypes
 import GLMakie
@@ -53,7 +53,7 @@ import .TreeTypes
 
 Create geometry + color for the internodes
 
-````@example forest
+````julia
 function VirtualPlantLab.feed!(turtle::Turtle, i::TreeTypes.Internode, data)
     # Rotate turtle around the head to implement elliptical phyllotaxis
     rh!(turtle, data.phyllotaxis)
@@ -65,7 +65,7 @@ end
 
 Create geometry + color for the leaves
 
-````@example forest
+````julia
 function VirtualPlantLab.feed!(turtle::Turtle, l::TreeTypes.Leaf, data)
     # Rotate turtle around the arm for insertion angle
     ra!(turtle, -data.leaf_angle)
@@ -80,7 +80,7 @@ end
 
 Insertion angle for the bud nodes
 
-````@example forest
+````julia
 function VirtualPlantLab.feed!(turtle::Turtle, b::TreeTypes.BudNode, data)
     # Rotate turtle around the arm for insertion angle
     ra!(turtle, -data.branch_angle)
@@ -89,7 +89,7 @@ end
 
 Rules
 
-````@example forest
+````julia
 meristem_rule = Rule(TreeTypes.Meristem, rhs = mer -> TreeTypes.Node() +
                                               (TreeTypes.Bud(), TreeTypes.Leaf()) +
                                          TreeTypes.Internode() + TreeTypes.Meristem())
@@ -126,7 +126,7 @@ of each tree and rotates it.
 (ii) Wrap the axiom, rules and the creation of the graph into a function that
 takes the required parameters as inputs.
 
-````@example forest
+````julia
 function create_tree(origin, growth, budbreak, orientation)
     axiom = T(origin) + RH(orientation) + TreeTypes.Internode() + TreeTypes.Meristem()
     tree =  Graph(axiom = axiom, rules = (meristem_rule, branch_rule),
@@ -138,7 +138,7 @@ end
 The code for elongating the internodes to simulate growth remains the same as for
 the binary tree example
 
-````@example forest
+````julia
 getInternode = Query(TreeTypes.Internode)
 
 function elongate!(tree, query)
@@ -166,13 +166,13 @@ of 2 meters. First we generate the original positions of the trees. For the
 position we just need to pass a `Vec` object with the x, y, and z coordinates of
 the location of each TreeTypes. The code below will generate a matrix with the coordinates:
 
-````@example forest
+````julia
 origins = [Vec(i,j,0) for i = 1:2.0:20.0, j = 1:2.0:20.0]
 ````
 
 We may assume that the initial orientation is uniformly distributed between 0 and 360 degrees:
 
-````@example forest
+````julia
 orientations = [rand()*360.0 for i = 1:2.0:20.0, j = 1:2.0:20.0]
 ````
 
@@ -181,22 +181,22 @@ LogNormal and Beta distribution, respectively. We can generate random
 values from these distributions using the `Distributions` package. For the
 relative growth rate:
 
-````@example forest
+````julia
 growths = rand(LogNormal(-2, 0.3), 10, 10)
 histogram(vec(growths))
 ````
 
 And for the budbreak parameter:
 
-````@example forest
+````julia
 budbreaks = rand(Beta(2.0, 10), 10, 10)
 histogram(vec(budbreaks))
 ````
 
 Now we can create our forest by calling the `create_tree` function we defined earlier
 with the correct inputs per tree:
 
-````@example forest
+````julia
 forest = vec(create_tree.(origins, growths, budbreaks, orientations));
 nothing #hide
 ````
@@ -214,22 +214,22 @@ as you may need to change some settings in your computer).
 We can simulate the growth of each tree by applying the method `simulate` to each
 tree, creating a new version of the forest (the code below is an array comprehension)
 
-````@example forest
+````julia
 newforest = [simulate(tree, getInternode, 2) for tree in forest];
 nothing #hide
 ````
 
 And we can render the forest with the function `render` as in the binary tree
 example but passing the whole forest at once
 
-````@example forest
+````julia
 render(Scene(newforest))
 ````
 
 If we iterate 4 more iterations we will start seeing the different individuals
 diverging in size due to the differences in growth rates
 
-````@example forest
+````julia
 newforest = [simulate(tree, getInternode, 15) for tree in newforest];
 render(Scene(newforest))
 ````
@@ -243,7 +243,7 @@ and execute the iterations of the loop in multiple threads using the macro `@thr
 Note that the rendering function can also be ran in parallel (i.e. the geometry will be
 generated separately for each plant and the merge together):
 
-````@example forest
+````julia
 using Base.Threads
 newforest = deepcopy(forest)
 @threads for i in eachindex(forest)
@@ -254,7 +254,7 @@ render(Scene(newforest), parallel = true)
 
 An alternative way to perform the simulation is to have an outer loop for each timestep and an internal loop over the different trees. Although this approach is not required for this simple model, most FSP models will probably need such a scheme as growth of each individual plant will depend on competition for resources with neighbouring plants. In this case, this approach would look as follows:
 
-````@example forest
+````julia
 newforest = deepcopy(forest)
 for step in 1:15
     @threads for i in eachindex(newforest)
@@ -271,7 +271,7 @@ tweaking the 3D representation. When we want to combine plants generated from gr
 geometric element it is best to combine all these geometries in a `GLScene` object. We can start the scene
 with the `newforest` generated in the above:
 
-````@example forest
+````julia
 scene = Scene(newforest);
 nothing #hide
 ````
@@ -284,15 +284,15 @@ above when we determined the origin of each plant. VPL offers some shortcuts: `O
 passing the desired length as input. Below, a rectangle is created on the XY plane with the origin as a
 corner and each side being 11 units long:
 
-````@example forest
+````julia
 soil = Rectangle(length = 21.0, width = 21.0)
 rotatey!(soil, pi/2)
 VirtualPlantLab.translate!(soil, Vec(0.0, 10.5, 0.0))
 ````
 
 We can now add the `soil` to the `scene` object with the `add!` function.
 
-````@example forest
+````julia
 VirtualPlantLab.add!(scene, mesh = soil, color = RGB(1,1,0))
 ````
 
@@ -302,7 +302,7 @@ your code but also to help setup the scene (e.g. if you are not sure how big the
 Howver, it may be distracting for the visualization. It turns out that we can turn that off with
 `show_axes = false`:
 
-````@example forest
+````julia
 render(scene, axes = false)
 ````
 
@@ -312,7 +312,7 @@ we can run the `save_scene` function on the object returned from `render`. The a
 `render` to increase the number of pixels in the final image. A helper function `calculate_resolution` is provided to
 compute the resolution from a physical width and height in cm and a dpi (e.g., useful for publications and posters):
 
-````@example forest
+````julia
 res = calculate_resolution(width = 16.0, height = 16.0, dpi = 1_000)
 output = render(scene, axes = false, resolution = res)
 export_scene(scene = output, filename = "nice_trees.png")