Merge pull request #218 from ReactiveBayes/214-documentation-for-resizablearray-is-missing

add docs for resizablearray

Author: wouterwln

docs/src/developers_guide.md

@@ -101,6 +101,14 @@ node = context[Normal, 1]
 nothing # hide
 ```
 
+## ResizableArrays
+
+`GraphPPL` uses `ResizableArrays` to store arrays of random variables. A `ResizableArray` is a mutable array that can grow dynamically when data is assigned to it. This is why the `x[i] ~ Normal(0, 1)` syntax is allowed in `GraphPPL`; the `ResizableArray` `x` will check if `i` is a valid index and grow the array if necessary. 
+```@docs
+GraphPPL.ResizableArray
+```
+`ResizableArray` is a subtype of `AbstractArray`, and implements all the functions that are expected from an array. Note that `size` returns the largest size of the array across each dimension, so an array of size `(2, 3)` does not necessarily has to have an element stored at index `(2, 3)`, instead there exists a vector of length 3 along the second dimension.
+
 ## Model creation engine internal 
 
 ```@docs

src/resizable_array.jl

@@ -1,5 +1,16 @@
 import Base: size, setindex!, getindex, show, vec
 
+"""
+    ResizableArray{T, V, N} <: AbstractArray{T, N}
+
+A ResizableArray is an array that can grow in any dimension. It handles like a regular AbstractArray when calling `getindex`, but for `setindex!` 
+it will automatically resize the array if the index is out of bounds. It is also possible to iterate over the array in the same way as for a regular array.
+The data is stored internally as a recursive vector. The depth of the recursion is fixed at construction time and cannot be changed. 
+
+# Constructor
+- `ResizableArray(::Type{T})`: Create an empty resizable array of type `T` with depth 1, similar to a vector.
+- `ResizableArray(::Type{T}, ::Val{N})`: Create an empty resizable array of type `T` with depth `N`, similar to AbstractArray{T, N}.
+"""
 struct ResizableArray{T, V <: AbstractVector, N} <: AbstractArray{T, N}
     data::V
 end
@@ -28,8 +39,6 @@ function ResizableArray(array::AbstractVector{T}) where {T}
     return ResizableArray{V, Vector{T}, get_recursive_depth(array)}(array)
 end
 
-# ResizableArray(A::AbstractArray{T, N}) where {T, N} = ResizableArray{T, typeof(A), N}(A)
-
 function make_recursive_vector(::Type{T}, ::Val{1}) where {T}
     return T[]
 end