Clean docstrings

Co-Authored-By: Claudio Moroni <43729990+ClaudMor@users.noreply.github.com>
Co-Authored-By: Pietro Monticone <38562595+pitmonticone@users.noreply.github.com>

Author: 3 people

docs/src/index.md

@@ -120,7 +120,7 @@ multilayervertices_meta[1]
 MV(Node("node_1"), :nothing, ("I'm node node_1",))
 ```
 
-Where `MV` is an alias for `MultilayerVertex`. The first field is the `Node` being represented (accessible via the [`node`](@ref) function), the second the (name of) the layer the vertex is represented in (accessible via the [`layer`](@ref) function, here it is set to `nothing`, since these vertices are yet to be assigned), and the metadata associated to the vertex (accessible via the [`metadata`](@ref) function, no metadata are currently represented via an empty `NamedTuple`). `MultilayerVertex` metadata can be represented via a `Tuple` or a `NamedTuple` (see below for examples). For a complete list of methods applicable to `MultilayerVertices`, plese refer to the [Vertices](@ref vertices_eu) of the API.
+Where `MV` is an alias for `MultilayerVertex`. The first field is the `Node` being represented (accessible via the [`node`](@ref) function), the second the (name of) the layer the vertex is represented in (accessible via the [`layer`](@ref) function, here it is set to `nothing`, since these vertices are yet to be assigned), and the metadata associated to the vertex (accessible via the [`metadata`](@ref) function, no metadata are currently represented via an empty `NamedTuple`). `MultilayerVertex` metadata can be represented via a `Tuple` or a `NamedTuple` (see below for examples). For a complete list of methods applicable to `MultilayerVertices`, please refer to the [Vertices](@ref vertices_eu) of the API.
 
 ### Layers
 
@@ -142,7 +142,7 @@ Layer(
 
 A `Layer` is considered "weighted" if its underlying graph (`null_graph` argument) has been given the `IsWeighted` trait (traits throughout this package are implemented via [SimpleTraits.jl](https://github.com/mauro3/SimpleTraits.jl), just like Graphs.jl does). Since one may at any moment add a new weighted `Layer` to a `MultilayerGraph` (see below for details), the latter is always considered a "weighted graph", so it is given the `IsWeighted` trait. Thus, all `Layer`s and `Interlayer`s (collectively named "subgraphs" hereafter) must specify their `weighttype` as the last argument of their constructor, so the user may debug their weight matrices ([`weights(subgraph::AbstractSubGraph)`](@ref)) immediately after construction. As better specified below, all subgraphs that are meant to be part of the same `MultilayerGraph` must have the same `weighttype`. Moreover, also the vertex type `T` (i.e. the internal representation of vertices) should be the same.
 
-Before instantiating `Layer`s, we define an utility function to ease randomization:
+Before instantiating `Layer`s, we define an utility function to ease randomisation:
 
 ```julia
 # Utility function that returns a random number of vertices and edges each time it is called:
@@ -228,7 +228,7 @@ layers = [layer_sg, layer_swg, layer_mg, layer_vg]
 
 The API that inspects and modifies `Layer`s will be shown below together with that of `Interlayer`s, since they are usually the same.  There are of course other constructors that you may discover by reading the [API](@ref subgraphs_eu). They include:
 
-1. Constructors that exempt the user from having to explictly specify the `null_graph`, at the cost of some flexibility;
+1. Constructors that exempt the user from having to explicitly specify the `null_graph`, at the cost of some flexibility;
 2. Constructors that allow for a configuration model-like specifications.
 
 ### Interlayers
@@ -321,7 +321,7 @@ interlayer_empty_sg_vg = empty_interlayer(  layer_sg,
 interlayers = [interlayer_sg_swg, interlayer_swg_mg, interlayer_mg_vg, interlayer_multiplex_sg_mg, interlayer_empty_sg_vg]
 ```
 
-There are of course other constructors that you may discover by reading the [API](@ref subgraphs_eu). They include constructors that exempt the user from having to explictly specify the `null_graph`, at the cost of some flexibility;
+There are of course other constructors that you may discover by reading the [API](@ref subgraphs_eu). They include constructors that exempt the user from having to explicitly specify the `null_graph`, at the cost of some flexibility;
 
 Next, we explore the API associated to modify and analyze `Layer`s and `Interlayer`s.
 
@@ -649,7 +649,7 @@ It is used as:
 
 ```julia
 # The configuration model-like constructor will be responsible for creating the edges, so we need to provide it with empty layers and interlayers.
-# To create empty layers and interlayers, we will empty the above subgraphs, and, for compatobility reasons, we'll remove the ones having a `SimpleWeightedGraph`s. These lines are not necessary to comprehend the tutorial, they may be skipped. Just know that the variables `empty_layers` and `empty_interlayers` are two lists of, respectively, empty layers and interlayers that do not have `SimpleWeightedGraph`s as their underlying graphs
+# To create empty layers and interlayers, we will empty the above subgraphs, and, for compatibility reasons, we'll remove the ones having a `SimpleWeightedGraph`s. These lines are not necessary to comprehend the tutorial, they may be skipped. Just know that the variables `empty_layers` and `empty_interlayers` are two lists of, respectively, empty layers and interlayers that do not have `SimpleWeightedGraph`s as their underlying graphs
 
 empty_layers =  deepcopy([layer for layer in layers if !(layer.graph isa SimpleWeightedGraphs.AbstractSimpleWeightedGraph)])
 

src/MultilayerGraphs.jl

@@ -14,7 +14,7 @@
 
 # The δ_Ω implementation could be moved to a separate file.
 
-# The usage of mutable `MissingVertex`s (although limited to SupraWeightMatrix) points to the fact that Bijections (at least as they are used right now) are not the best way to represent integer label-MultilayerVertex associations. We my implement our own container object or use the exixtsing ons differently.
+# The usage of mutable `MissingVertex`s (although limited to SupraWeightMatrix) points to the fact that Bijections (at least as they are used right now) are not the best way to represent integer label-MultilayerVertex associations. We my implement our own container object or use the existing ons differently.
 
 # We need a quick Multilayer(Di)Graph constructor of the form Multilayer(Di)Graph(nn, nl; nv = rand(0:nn*nl), ne = rand(0:nv*(nv-1)) kwargs...) where kwargs may be used to further specify it.
 

src/abstractmultilayergraph.jl

@@ -1188,7 +1188,7 @@ function get_rich_mv(
 ) where {T,U,M<:AbstractMultilayerGraph{T,U}}
     if perform_checks
         haskey(mg.v_V_associations, i) ||
-            throw(ErrorException("$i is not a vertex of the multilayer graph"))
+            throw(ErrorException("$i is not a vertex of the multilayer graph."))
     end
 
     bare_V = mg.v_V_associations[i]

src/multilayerdigraph.jl

@@ -9,7 +9,7 @@ mutable struct MultilayerDiGraph{T,U} <: AbstractMultilayerDiGraph{T,U}
     v_V_associations::Bijection{T,<:MultilayerVertex} # A Bijection from Bijections.jl that associates numeric vertices to `MultilayerVertex`s.
     idx_N_associations::Bijection{Int64,Node} # A Bijection from Bijections.jl that associates Int64 to `Node`s.
     fadjlist::Vector{Vector{HalfEdge{<:MultilayerVertex,<:Union{Nothing,U}}}} # the forward adjacency list of the MultilayerDiGraph. It is a vector of vectors of `HalfEdge`s. Its i-th element are the `HalfEdge`s that originate from `v_V_associations[i]`.
-    badjlist::Vector{Vector{HalfEdge{<:MultilayerVertex,<:Union{Nothing,U}}}} # the bacward adjacency list of the MultilayerDiGraph. It is a vector of vectors of `HalfEdge`s. Its i-th element are the `HalfEdge`s that insost on `v_V_associations[i]`.
+    badjlist::Vector{Vector{HalfEdge{<:MultilayerVertex,<:Union{Nothing,U}}}} # the backward adjacency list of the MultilayerDiGraph. It is a vector of vectors of `HalfEdge`s. Its i-th element are the `HalfEdge`s that insist on `v_V_associations[i]`.
     v_metadata_dict::Dict{T,<:Union{<:Tuple,<:NamedTuple}} # A Dictionary that associates numeric vertices to their metadata
 end
 
@@ -203,7 +203,7 @@ function MultilayerDiGraph(
     perform_checks::Bool=false,
 ) where {T,U}
     (allow_self_loops && perform_checks) &&
-        @warn "Checks for graphicality and coherence with the provided `empty_multilayerdigraph` are currently performed without taking into account self-loops. Thus said checks may fail event though the provided `indegree_sequence` and `outdegree_sequence` may be graphical when one allows for self-loops within the directed multilayer graph to be present. If you are sure that the provided `indegree_sequence` and `outdegree_sequence` are indeed graphical under those circumstances, you may want to disable checks by setting `perform_checks = false`. We apologize for the inconvenient."
+        @warn "Checks for graphicality and coherence with the provided `empty_multilayerdigraph` are currently performed without taking into account self-loops. Thus said checks may fail event though the provided `indegree_sequence` and `outdegree_sequence` may be graphical when one allows for self-loops within the directed multilayer graph to be present. If you are sure that the provided `indegree_sequence` and `outdegree_sequence` are indeed graphical under those circumstances, you may want to disable checks by setting `perform_checks = false`. We apologize for the inconvenience."
 
     _multilayerdigraph = deepcopy(empty_multilayerdigraph)
 
@@ -217,19 +217,19 @@ function MultilayerDiGraph(
         n = nv(_multilayerdigraph)
         n == length(indegree_sequence) == length(outdegree_sequence) || throw(
             ErrorException(
-                "The number of vertices of the provided empty MultilayerDiGraph does not match the length of the `indegree_sequence` or the `outdegree_sequence`. Found $(nv(_multilayerdigraph)) , $(length(indegree_sequence)) and  $(length(outdegree_sequence))",
+                "The number of vertices of the provided empty MultilayerDiGraph does not match the length of the `indegree_sequence` or the `outdegree_sequence`. Found $(nv(_multilayerdigraph)) , $(length(indegree_sequence)) and  $(length(outdegree_sequence)).",
             ),
         )
 
         sum(indegree_sequence) == sum(outdegree_sequence) || throw(
             ErrorException(
-                "The sum of the `indegree_sequence` and the `outdegree_sequence` must match. Found $(sum(indegree_sequence)) and $(sum(outdegree_sequence))",
+                "The sum of the `indegree_sequence` and the `outdegree_sequence` must match. Found $(sum(indegree_sequence)) and $(sum(outdegree_sequence)).",
             ),
         )
 
         isdigraphical(degree_sequence) || throw(
             ArgumentError(
-                "`indegree_sequence` and `outdegree_sequence` must be digraphical"
+                "`indegree_sequence` and `outdegree_sequence` must be digraphical."
             ),
         )
     end

src/multilayergraph.jl

@@ -29,9 +29,9 @@ Construct a MultilayerGraph with layers given by `layers`. The interlayers will
 # ARGUMENTS
 
 - `layers::Vector{<:Layer{T,U}}`: The (ordered) list of layers the multilayer graph will have;
-- `specified_interlayers::Vector{<:Interlayer{T,U}}`: The list of interlayers specified by the user. Note that the user does not need to specify all interlayers, as the unspecified ones will be automatically constructed using the indications given by the `default_interlayers_null_graph` and `default_interlayers_structure` keywords.;
-- `default_interlayers_null_graph::H = SimpleGraph{T}()`: Sets the underlying graph for the interlayers that are to be automatically specified. Defaults to `SimpleGraph{T}()`. See the `Layer` constructors for more information.;
-- `default_interlayers_structure::String = "multiplex"`: Sets the structure of the interlayers that are to be automatically specified. May be "multiplex" for diagonally coupled interlayers, or "empty" for empty interlayers (no edges).  "multiplex". See the `Interlayer` constructors for more information.;
+- `specified_interlayers::Vector{<:Interlayer{T,U}}`: The list of interlayers specified by the user. Note that the user does not need to specify all interlayers, as the unspecified ones will be automatically constructed using the indications given by the `default_interlayers_null_graph` and `default_interlayers_structure` keywords;
+- `default_interlayers_null_graph::H = SimpleGraph{T}()`: Sets the underlying graph for the interlayers that are to be automatically specified. Defaults to `SimpleGraph{T}()`. See the `Layer` constructors for more information;
+- `default_interlayers_structure::String = "multiplex"`: Sets the structure of the interlayers that are to be automatically specified. May be "multiplex" for diagonally coupled interlayers, or "empty" for empty interlayers (no edges).  "multiplex". See the `Interlayer` constructors for more information.
 """
 function MultilayerGraph(
     layers::Vector{<:Layer{T,U}},

src/traits.jl

@@ -25,7 +25,7 @@ is_weighted(g::G) where {G<:Type{<:AbstractGraph}} = istrait(IsWeighted{g})
 """
     IsMeta{X}
 
-Trait that discerns between graphs that sport edge and vertex  metadata.
+Trait that discerns between graphs that sport edge and vertex metadata.
 """
 @traitdef IsMeta{X}
 

src/utilities.jl

@@ -655,8 +655,8 @@ Returns a simple directed graph with given finite in-degree and out-degree seque
 4. Repeat from 1. until all indegree-outdegree pairs are of the form (0.0).
 
 ## References
-- [Wikipedia](https://en.wikipedia.org/wiki/Kleitman%E2%80%93Wang_algorithms)
-- [Kleitman and Wang (1973)](https://doi.org/10.1016/0012-365X(73)90037-X)
+- [Wikipedia](https://en.wikipedia.org/wiki/Kleitman%E2%80%93Wang_algorithms);
+- [Kleitman and Wang (1973)](https://doi.org/10.1016/0012-365X(73)90037-X).
 """
 function kleitman_wang_graph_generator(
     indegree_sequence::AbstractVector{<:Integer},
@@ -724,7 +724,7 @@ end
 """
     sample_graphical_degree_sequence(degree_distribution::UnivariateDistribution, n::Integer)
 
-Sample a graphical degree sequence for a graph with `n` vertices from `degree_distribution`
+Sample a graphical degree sequence for a graph with `n` vertices from `degree_distribution`.
 """
 function sample_graphical_degree_sequence(
     degree_distribution::UnivariateDistribution, n::Integer