Include more docs on Quorum and bump patch version

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rldb"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 description = "A dynamo-like key/value database written in rust"
 authors = ["Rafael Leite"]

src/cluster/quorum/min_required_replicas.rs

@@ -22,6 +22,9 @@ pub struct MinRequiredReplicas<T, E> {
 
 impl<T, E> MinRequiredReplicas<T, E> {
     /// Constructs a new instance of [`MinRequiredReplicas`]
+    ///
+    /// # Error
+    /// This function returns an error if the provided `n_replicas` arugment is less than `required_successes`
     pub fn new(n_replicas: usize, required_successes: usize) -> Result<Self> {
         if n_replicas < required_successes {
             return Err(Error::Logic {

src/cluster/quorum/mod.rs

@@ -21,10 +21,14 @@ pub enum Evaluation {
     Unreachable,
 }
 
+/// The result of a [`Quorum::finish`] call
 #[derive(Debug)]
 pub struct QuorumResult<T, E> {
+    /// The quorum evaluation - see [`Evaluation`]
     pub evaluation: Evaluation,
+    /// successful items
     pub successes: Vec<T>,
+    /// failed items
     pub failures: Vec<E>,
 }
 

src/cmd/get.rs

@@ -64,6 +64,11 @@ impl Get {
 
                 // TODO: we are waiting for all nodes on the preference list to return either error or success
                 // this will cause latency issues and it's no necessary.. fix it later
+                // Note: The [`crate::cluster::quorum::Quorum`] API already handles early evaluation
+                // in case quorum is not reachable. The change to needed here is fairly small in this regard.
+                // What's missing is deciding on:
+                //  1. what do we do with inflight requests in case of an early success?
+                //  2. (only for the PUT case) what do we do with successful PUT requests? rollback? what does that look like?
                 while let Some(res) = futures.next().await {
                     match res {
                         Ok(res) => {

src/cmd/put.rs

@@ -86,6 +86,8 @@ impl Put {
                 // for now, let's wait til all futures either succeed or fail.
                 // we don't strictly need that since we are quorum based..
                 // doing it this way now for simplicity but this will have a latency impact
+                //
+                // For more info, see similar comment on [`crate::cmd::get::Get`]
                 while let Some(res) = futures.next().await {
                     match res {
                         Ok(_) => {