docs: Improve documentation of snippet-trait read_only_algorithm

Author: Sword-Smith

tasm-lib/src/traits/accessor.rs

@@ -23,12 +23,14 @@ use super::rust_shadow::RustShadow;
 /// stack but can only read from memory. Note that it cannot write to static
 /// memory. It cannot read from any inputs or write to standard out. It cannot
 /// modify the sponge state.
-/// See also: [closure], [function], [procedure], [algorithm], [mem_preserver]
+/// See also: [closure], [function], [procedure], [algorithm],
+///           [read_only_algorithm], [mem_preserver]
 ///
 /// [closure]: crate::traits::closure::Closure
 /// [function]: crate::traits::function::Function
 /// [procedure]: crate::traits::procedure::Procedure
 /// [algorithm]: crate::traits::algorithm::Algorithm
+/// [read_only_algorithm]: crate::traits::read_only_algorithm::ReadOnlyAlgorithm
 /// [mem_preserver]: crate::traits::mem_preserver::MemPreserver
 pub trait Accessor: BasicSnippet {
     fn rust_shadow(

tasm-lib/src/traits/algorithm.rs

@@ -23,13 +23,15 @@ use super::rust_shadow::RustShadow;
 /// the dynamic memory allocator, and can take nondeterministic input. It cannot read from
 /// standard in or write to standard out.
 ///
-/// See also: [closure], [function], [procedure], [accessor], [mem_preserver]
+/// See also: [closure], [function], [procedure], [accessor], [mem_preserver],
+///           [read_only_algorithm]
 ///
 /// [closure]: crate::traits::closure::Closure
 /// [function]: crate::traits::function::Function
 /// [procedure]: crate::traits::procedure::Procedure
 /// [accessor]: crate::traits::accessor::Accessor
 /// [mem_preserver]: crate::traits::mem_preserver::MemPreserver
+/// [read_only_algorithm]: crate::traits::read_only_algorithm::ReadOnlyAlgorithm
 pub trait Algorithm: BasicSnippet {
     fn rust_shadow(
         &self,

tasm-lib/src/traits/closure.rs

@@ -18,13 +18,15 @@ use super::rust_shadow::RustShadow;
 /// A Closure is a piece of tasm code that modifies the top of the stack without access to
 /// memory or nondeterminism or standard input/output.
 ///
-/// See also: [function], [algorithm], [procedure], [accessor], [mem_preserver]
+/// See also: [function], [algorithm], [read_only_algorithm], [procedure],
+///           [accessor], [mem_preserver]
 ///
 /// [function]: crate::traits::function::Function
 /// [algorithm]: crate::traits::algorithm::Algorithm
 /// [procedure]: crate::traits::procedure::Procedure
 /// [accessor]: crate::traits::accessor::Accessor
 /// [mem_preserver]: crate::traits::mem_preserver::MemPreserver
+/// [read_only_algorithm]: crate::traits::read_only_algorithm::ReadOnlyAlgorithm
 pub trait Closure: BasicSnippet {
     fn rust_shadow(&self, stack: &mut Vec<BFieldElement>);
 

tasm-lib/src/traits/function.rs

@@ -24,10 +24,13 @@ use super::rust_shadow::RustShadow;
 /// larger than the dynamic memory allocator and the dynamic memory allocator value has to
 /// be updated accordingly.
 ///
-/// See also: [closure], [algorithm], [procedure], [accessor], [mem_preserver]
+/// See also: [closure], [algorithm], [read_only_algorithm], [procedure],
+///           [accessor], [mem_preserver],
+///
 ///
 /// [closure]: crate::traits::closure::Closure
 /// [algorithm]: crate::traits::algorithm::Algorithm
+/// [read_only_algorithm]: crate::traits::read_only_algorithm::ReadOnlyAlgorithm
 /// [procedure]: crate::traits::procedure::Procedure
 /// [accessor]: crate::traits::accessor::Accessor
 /// [mem_preserver]: crate::traits::mem_preserver::MemPreserver

tasm-lib/src/traits/mem_preserver.rs

@@ -22,12 +22,14 @@ use super::rust_shadow::RustShadow;
 /// An MemPreserver is a piece of tasm code that can do pretty much everything
 /// except modify memory, including static memory. It can read from any input
 /// and write to standard out. It can also modify the sponge state.
-/// See also: [closure], [function], [procedure], [algorithm], [accessor]
+/// See also: [closure], [function], [procedure], [algorithm],
+///           [read_only_algorithm], [accessor]
 ///
 /// [closure]: crate::traits::closure::Closure
 /// [function]: crate::traits::function::Function
 /// [procedure]: crate::traits::procedure::Procedure
 /// [algorithm]: crate::traits::algorithm::Algorithm
+/// [read_only_algorithm]: crate::traits::read_only_algorithm::ReadOnlyAlgorithm
 /// [accessor]: crate::traits::accessor::Accessor
 pub trait MemPreserver: BasicSnippet {
     fn rust_shadow(

tasm-lib/src/traits/procedure.rs

@@ -30,11 +30,13 @@ use crate::VmHasher;
 /// in a function (lower case f, as in 'labelled scope'); and cannot be proved as
 /// a standalone program.
 ///
-/// See also: [closure], [function], [algorithm], [accessor], [mem_preserver]
+/// See also: [closure], [function], [algorithm], [read_only_algorithm],
+///           [accessor], [mem_preserver]
 ///
 /// [closure]: crate::traits::closure::Closure
 /// [function]: crate::traits::function::Function
 /// [algorithm]: crate::traits::algorithm::Algorithm
+/// [read_only_algorithm]: crate::traits::read_only_algorithm::ReadOnlyAlgorithm
 /// [accessor]: crate::traits::accessor::Accessor
 /// [mem_preserver]: crate::traits::mem_preserver::MemPreserver
 pub trait Procedure: BasicSnippet {

tasm-lib/src/traits/read_only_algorithm.rs

@@ -22,6 +22,16 @@ use super::rust_shadow::RustShadow;
 ///
 /// An ReadOnlyAlgorithm is a piece of tasm code that can read memory and read
 /// from non-determinism.
+///
+/// See also: [closure], [function], [procedure], [accessor], [mem_preserver],
+///           [algorithm]
+///
+/// [closure]: crate::traits::closure::Closure
+/// [function]: crate::traits::function::Function
+/// [procedure]: crate::traits::procedure::Procedure
+/// [accessor]: crate::traits::accessor::Accessor
+/// [mem_preserver]: crate::traits::mem_preserver::MemPreserver
+/// [algorithm]: crate::traits::algorithm::Algorithm
 pub trait ReadOnlyAlgorithm: BasicSnippet {
     fn rust_shadow(
         &self,