make format of docs for consistency checks more consistent

Author: intarga

src/checks/consistency/greater_than.rs

@@ -3,9 +3,10 @@ use crate::Flag;
 /// Consistency check between 2 climate parameters, where one (including a correction) should
 /// never be greater than the other.
 ///
-/// Returns [`Flag::DataMissing`] if either datum is missing,
-/// [`Flag::Fail`] if datum1 + datum1_correction > datum2,
-/// [`Flag::Pass`] otherwise.
+/// Returns:
+/// - [`Flag::DataMissing`] if either datum is missing,
+/// - [`Flag::Fail`] if datum1 + datum1_correction > datum2,
+/// - [`Flag::Pass`] otherwise.
 pub fn greater_than(datum1: Option<f32>, datum2: Option<f32>, datum1_correction: f32) -> Flag {
     if datum1.is_none() || datum2.is_none() {
         return Flag::DataMissing;

src/checks/consistency/max_greater_than_single.rs

@@ -3,11 +3,13 @@ use crate::Flag;
 /// Compares a single value to a higher resolution sequence, where the maximum value in the
 /// sequence (including an adjustment) should never be greater than the single value
 ///
-/// If this invariant is broken (i.e the maximum of the sequence, plus the adjustment, is greater
-/// than the single value), we return [`Flag::Fail`].
-/// Else, if any of the elements is missing, we return [`Flag::DataMissing`], as we cannot be sure
-/// a missing data point did not violate the invariant.
-/// Else we return [`Flag::Pass`].
+/// Returns:
+/// - [`Flag::DataMissing`] if the single value is missing,
+/// - [`Flag::Fail`] if this invariant is broken (i.e the maximum of the sequence, plus the
+///   adjustment, is greater than the single value),
+/// - [`Flag::DataMissing`] if any of the elements is missing, as we cannot be sure a missing data
+///   point did not violate the invariant.
+/// - [`Flag::Pass`] otherwise.
 pub fn max_greater_than_single(
     single: Option<f32>,
     sequence: &[Option<f32>],

src/checks/consistency/max_less_than_single.rs

@@ -3,11 +3,13 @@ use crate::Flag;
 /// Compares a single value to a higher resolution sequence, where the maximum value in the
 /// sequence (including an adjustment) should never be less than the single value
 ///
-/// If this invariant is broken (i.e the maximum of the sequence, plus the adjustment, is less
-/// than the single value), we return [`Flag::Fail`].
-/// Else, if any of the elements is missing, we return [`Flag::DataMissing`], as we cannot be sure
-/// a missing data point did not violate the invariant.
-/// Else we return [`Flag::Pass`].
+/// Returns:
+/// - [`Flag::DataMissing`] if the single value is missing,
+/// - [`Flag::Fail`] if this invariant is broken (i.e the maximum of the sequence, plus the
+///   adjustment, is less than the single value),
+/// - [`Flag::DataMissing`] if any of the elements is missing, as we cannot be sure a missing data
+///   point did not violate the invariant.
+/// - [`Flag::Pass`] otherwise.
 pub fn max_less_than_single(
     single: Option<f32>,
     sequence: &[Option<f32>],

src/checks/consistency/min_greater_than_single.rs

@@ -3,11 +3,13 @@ use crate::Flag;
 /// Compares a single value to a higher resolution sequence, where the minimum value in the
 /// sequence (including an adjustment) should never be greater than the single value
 ///
-/// If this invariant is broken (i.e the minimum of the sequence, plus the adjustment, is greater
-/// than the single value), we return [`Flag::Fail`].
-/// Else, if any of the elements is missing, we return [`Flag::DataMissing`], as we cannot be sure
-/// a missing data point did not violate the invariant.
-/// Else we return [`Flag::Pass`].
+/// Returns:
+/// - [`Flag::DataMissing`] if the single value is missing,
+/// - [`Flag::Fail`] if this invariant is broken (i.e the minimum of the sequence, plus the
+///   adjustment, is greater than the single value),
+/// - [`Flag::DataMissing`] if any of the elements is missing, as we cannot be sure a missing data
+///   point did not violate the invariant.
+/// - [`Flag::Pass`] otherwise.
 pub fn min_greater_than_single(
     single: Option<f32>,
     sequence: &[Option<f32>],

src/checks/consistency/min_less_than_single.rs

@@ -3,11 +3,13 @@ use crate::Flag;
 /// Compares a single value to a higher resolution sequence, where the minimum value in the
 /// sequence (including an adjustment) should never be less than the single value
 ///
-/// If this invariant is broken (i.e the minimum of the sequence, plus the adjustment, is less
-/// than the single value), we return [`Flag::Fail`].
-/// Else, if any of the elements is missing, we return [`Flag::DataMissing`], as we cannot be sure
-/// a missing data point did not violate the invariant.
-/// Else we return [`Flag::Pass`].
+/// Returns:
+/// - [`Flag::DataMissing`] if the single value is missing,
+/// - [`Flag::Fail`] if this invariant is broken (i.e the minimum of the sequence, plus the
+///   adjustment, is less than the single value),
+/// - [`Flag::DataMissing`] if any of the elements is missing, as we cannot be sure a missing data
+///   point did not violate the invariant.
+/// - [`Flag::Pass`] otherwise.
 pub fn min_less_than_single(
     single: Option<f32>,
     sequence: &[Option<f32>],

src/checks/consistency/not_equal.rs

@@ -6,9 +6,10 @@ use crate::Flag;
 /// Useful for comparing observations against model data, or comparing two instruments measuring
 /// the same climate parameter at the same site.
 ///
-/// Returns [`Flag::DataMissing`] if either datum is missing,
-/// [`Flag::Fail`] if the difference between datum1 and datum2 is greater than threshold,
-/// [`Flag::Pass`] otherwise.
+/// Returns:
+/// - [`Flag::DataMissing`] if either datum is missing,
+/// - [`Flag::Fail`] if the difference between datum1 and datum2 is greater than threshold,
+/// - [`Flag::Pass`] otherwise.
 pub fn not_equal(datum1: Option<f32>, datum2: Option<f32>, threshold: f32) -> Flag {
     if datum1.is_none() || datum2.is_none() {
         return Flag::DataMissing;