Algorithms should be good to go

Author: Nxirda

include/kumi/algorithm/apply.hpp

@@ -11,9 +11,9 @@ namespace kumi
 {
   //====================================================================================================================
   //! @ingroup transforms
-  //! @brief Invoke the Callable object f with the elements of product type unrolled as arguments.
+  //! @brief Invoke the Callable object f with the elements of the product type unrolled as arguments.
   //!
-  //! @note f is applied on the underlying values when the input `t` is a record type
+  //! `f` is applied on the underlying values when the input `t` is a record type
   //!
   //! @param f	Callable object to be invoked
   //! @param t  Product Type whose elements are used as arguments to f

include/kumi/algorithm/cast.hpp

@@ -35,7 +35,7 @@ namespace kumi
   //!
   //! @tparam Target destination type to associate to each member of the product type `t`
   //! @param  t Product type to convert
-  //! @return A Product type containing the values of t where each member is of type Target
+  //! @return A Product type containing the values of `t` where each member is of type Target
   //!
   //! ## Helper type
   //! @code

include/kumi/algorithm/contains.hpp

@@ -16,12 +16,12 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup queries
-  //! @brief Checks if a product type contains a given identifier
+  //! @ingroup  queries
+  //! @brief    Checks if a product type contains a given identifier
   //!
-  //! @param t the product type to inspect.
+  //! @param t  the product type to inspect.
   //! @param id Identifier to check
-  //! @return `true` if the current product_type contains a field named with the `id` identifier, and `false` otherwise.
+  //! @return   `true` if the `t` contains a field labeled with the `id` identifier, `false` otherwise.
   //!
   //! ## Examples:
   //! @include doc/tuple/algo/contains.cpp
@@ -45,12 +45,12 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup queries
-  //! @brief Checks if a product type contains at least one of many identifiers
+  //! @ingroup  queries
+  //! @brief    Checks if a product type contains at least one of many identifiers
   //!
-  //! @param t the product type to inspect.
-  //! @param ids Identifiers to check
-  //! @return `true` if current product_type contains a field based on the `ids`, and `false` otherwise.
+  //! @param t    the product type to inspect.
+  //! @param ids  Identifiers to check
+  //! @return     `true` if `t` contains a field labeld by one of the `ids`, and `false` otherwise.
   //!
   //! ## Examples:
   //! @include doc/tuple/algo/contains_any.cpp
@@ -65,12 +65,12 @@ namespace kumi
   }
 
   //==================================================================================================================
-  //! @ingroup queries
-  //! @brief Checks if a product type contains fields based only on selected identifiers
+  //! @ingroup  queries
+  //! @brief    Checks if a product type contains fields based only on selected identifiers
   //!
-  //! @param t the product type to inspect.
-  //! @param ids Identifiers to check
-  //! @return `true` if current the product_type contains a field based on any of the `ids`, and `false` otherwise.
+  //! @param t    the product type to inspect.
+  //! @param ids  Identifiers to check
+  //! @return     `true` if `t` contains a field labeled by any of the `ids`, and `false` otherwise.
   //!
   //! ## Examples:
   //! @include doc/tuple/algo/contains_only.cpp
@@ -89,12 +89,12 @@ namespace kumi
   }
 
   //==================================================================================================================
-  //! @ingroup queries
-  //! @brief Checks if a product type contains no fields based on any of the selected identifiers
+  //! @ingroup  queries
+  //! @brief    Checks if a product type contains no fields based on any of the selected identifiers
   //!
-  //! @param t the product type to inspect.
-  //! @param ids Identifiers to check
-  //! @return `true` if the current product_type contains no field based on any of the `ids`, and `false` otherwise.
+  //! @param t    the product type to inspect.
+  //! @param ids  Identifiers to check
+  //! @return     `true` if `t` contains no field labeled by any of the `ids`, and `false` otherwise.
   //!
   //! ## Examples:
   //! @include doc/tuple/algo/contains_none.cpp

include/kumi/algorithm/extract.hpp

@@ -10,19 +10,19 @@
 namespace kumi
 {
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Extracts a sub product type from a product type
+  //! @ingroup  generators
+  //! @brief    Extracts a sub product type from a product type
   //!
-  //! On record types, this function operates structurally and extract elements as if they were ordered. The considered
-  //! order is the order of declaration.
+  //! On record types, this function operates on elements as if they were ordered. The considered order is the order
+  //! of declaration.
   //!
   //! @note Does not participate in overload resolution if `I0` and `I1` do not verify that
   //!       `0 <= I0 <= I1 <= size_v<T>`.
   //! @param  t  Product Type to extract from
   //! @param  i0 Compile-time index of the first element to extract.
   //! @param  i1 Compile-time index past the last element to extract. By default, `i1` is equal to
   //!         `size_v<T>`.
-  //! @return A new product type containing to the selected elements of the input product type.
+  //! @return A new product type containing the selected elements of `t`.
   //!
   //! ## Helper type
   //! @code
@@ -62,18 +62,18 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Split a product type into two
+  //! @ingroup  generators
+  //! @brief    Split a product type into two
   //!
   //! Split a product type in two product_type containing all the elements before and after a given index.
-  //! On record types, this function operates structurally and extract elements as if they were ordered. The considered
-  //! order is the order of declaration.
+  //! On record types, this function operates on elements as if they were ordered. The considered order is the order
+  //! of declaration.
   //!
   //! @note Does not participate in overload resolution if `I0` is not in `[0, sizeof...(Ts)[`.
   //!
   //! @param  t Product Type to split.
   //! @param  i0 Compile-time index of the split pivot.
-  //! @return A new tuple containing the two sub product types cut at index I.
+  //! @return A new tuple containing the two sub parts of `t` cut at index I.
   //!
   //! ## Helper type
   //! @code

include/kumi/algorithm/find.hpp

@@ -10,16 +10,15 @@
 namespace kumi
 {
   //====================================================================================================================
-  //! @ingroup queries
-  //! @brief  Return the index of a value which type satisfies a given predicate
+  //! @ingroup  queries
+  //! @brief    Return the index of a value which type satisfies a given predicate
   //!
   //! On record types, this function operates as if the elements are ordered. The considered order is the order of
   //! declaration.
   //!
   //! @param  t Product Type to process
   //! @param  p Unary predicate. p must return a value convertible to `bool` for every element of t.
-  //! @return Integral index of the element inside the product type if present, kumi::size<T>::value
-  //!         otherwise.
+  //! @return Integral index of the element inside `t` if present, kumi::size<T>::value otherwise.
   //!
   //! ## Examples:
   //! @include doc/tuple/algo/locate.cpp

include/kumi/algorithm/flatten.hpp

@@ -82,15 +82,15 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Converts a product type of product types into a product type of all elements.
+  //! @ingroup  generators
+  //! @brief    Converts a product type of product types into a product type of all elements.
   //!
   //! On record types, the names of the outer record are concatenated to the inner ones ultimately constructing names
   //! such as "outer.inner". If the input is a product type containing record types or vice versa only the inner types
   //! matching the outer semantic will be flattened. Thus a record inside a tuple will not be flattened.
   //!
   //! @param t  Product type to flatten
-  //! @return   A product type composed of all elements of t flattened non-recursively
+  //! @return   A product type composed of all elements of `t` flattened non-recursively
   //!
   //! ## Helper type
   //! @code
@@ -127,8 +127,8 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Recursively converts a product type of product types into a product type of all elements.
+  //! @ingroup  generators
+  //! @brief    Recursively converts a product type of product types into a product type of all elements.
   //!
   //! Recursively converts a product type of product types `t` into a product type of all elements of
   //! said product types.
@@ -142,7 +142,7 @@ namespace kumi
   //!
   //! @param t  Product type to flatten
   //! @param f  Optional Callable object to apply when a sub-tuple is flattened
-  //! @return   A product type composed of all elements of t flattened recursively
+  //! @return   A product type composed of all elements of `t` flattened recursively
   //!
   //! ## Helper type
   //! @code
@@ -196,15 +196,15 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Convert a product type to a flat product type of pointers to each its components.
+  //! @ingroup  generators
+  //! @brief    Convert a product type to a flat product type of pointers to each its components.
   //!
   //! On record types, the names of the outer record are concatenated to the inner ones ultimately constructing names
   //! such as "outer.inner". If the input is a product type containing record types or vice versa only the inner types
   //! matching the outer semantic will be flattened. Thus a record inside a tuple will not be flattened.
   //!
   //! @param t  Product type to convert
-  //! @return   A flat product type composed of pointers to each elements of t.
+  //! @return   A flat product type composed of pointers to each elements of `t`.
   //!
   //! ## Helper type
   //! @code

include/kumi/algorithm/fold.hpp

@@ -10,8 +10,8 @@
 namespace kumi
 {
   //====================================================================================================================
-  //! @ingroup reductions
-  //! @brief Computes the generalized combination of all elements using a tail recursive call.
+  //! @ingroup  reductions
+  //! @brief    Computes the generalized combination of all elements using a tail recursive call.
   //!
   //! On record types, this function operates on the underlying values, not on the fields themselves.
   //!
@@ -51,8 +51,8 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup reductions
-  //! @brief Computes the generalized associative combination of all elements using a tail recursive call.
+  //! @ingroup  reductions
+  //! @brief    Computes the generalized associative combination of all elements using a tail recursive call.
   //!
   //! On record types, this function operates on the underlying values, not on the fields themselves.
   //!
@@ -90,8 +90,8 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup reductions
-  //! @brief Computes the generalized combination of all elements using a non-tail recursive call.
+  //! @ingroup  reductions
+  //! @brief    Computes the generalized combination of all elements using a non-tail recursive call.
   //!
   //! On record types, this function operates on the underlying values, not on the fields themselves.
   //!
@@ -131,8 +131,8 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup reductions
-  //! @brief Computes the generalized associative combinationof all elements using a non-tail recursive call.
+  //! @ingroup  reductions
+  //! @brief    Computes the generalized associative combinationof all elements using a non-tail recursive call.
   //!
   //! On record types, this function operates on the underlying values, not on the fields themselves.
   //!

include/kumi/algorithm/for_each.hpp

@@ -10,9 +10,9 @@
 namespace kumi
 {
   //====================================================================================================================
-  //! @ingroup transforms
-  //! @brief Applies the Callable object f on each element of a product type. f is applied on the
-  //!        values if the given product_type is a record type.
+  //! @ingroup  transforms
+  //! @brief    Applies the Callable object f on each element of a product type. `f` is applied on the values if the
+  //!           given product_type is a record type.
   //!
   //! @note This function does not take part in overload resolution if `f` can't be applied to the
   //!       elements of `t` and/or `ts`.
@@ -58,8 +58,8 @@ namespace kumi
   }
 
   //================================================================================================
-  //! @ingroup tuple_transforms
-  //! @brief Applies the Callable object f on each element of a product type and its index.
+  //! @ingroup  tuple_transforms
+  //! @brief    Applies the Callable object `f` on each element of a product type and its index.
   //!
   //! @note This function does not take part in overload resolution if `f` can't be applied to the
   //!       elements of `t` and/or `ts` and an integral constant. This function cannot be applied
@@ -92,11 +92,11 @@ namespace kumi
 
   //================================================================================================
   //! @ingroup record_transforms
-  //! @brief Applies the Callable object f on each element of a record type and its field.
+  //! @brief Applies the Callable object `f` on each element of a record type and its field.
   //!
   //! @note This function does not take part in overload resolution if `f` can't be applied to the
   //!       elements of `t` and those of `ts`. This function can only be applied to record types.
-  //!       The function needs to be define to handle types modeling kumi::concepts::field.
+  //!       The function needs to be defined to handle types modeling kumi::concepts::field.
   //!
   //! @param f	  Callable object to be invoked
   //! @param r    Record type whose fields are used as arguments to f

include/kumi/algorithm/generate.hpp

@@ -10,8 +10,8 @@
 namespace kumi
 {
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Creates a kumi::tuple containing `N` copies of `v`.
+  //! @ingroup  generators
+  //! @brief    Creates a kumi::tuple containing `N` copies of `v`.
   //!
   //! @tparam N Number of replications
   //! @param  v Value to replicate
@@ -42,8 +42,8 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Creates a kumi::tuple containing `N` applications of the `f` Callable.
+  //! @ingroup  generators
+  //! @brief    Creates a kumi::tuple containing `N` applications of the `f` Callable.
   //!
   //! @tparam N Number of replications
   //! @param  f Callable to apply
@@ -73,8 +73,8 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup generators
-  //! @brief Creates a kumi::tuple containing an increasing ramp of values.
+  //! @ingroup  generators
+  //! @brief    Creates a kumi::tuple containing an increasing ramp of values.
   //!
   //! @tparam N Number of replications
   //! @param  v Seed value

include/kumi/algorithm/inner_product.hpp

@@ -34,13 +34,13 @@ namespace kumi
   }
 
   //====================================================================================================================
-  //! @ingroup reductions
-  //! @brief Computes inner product (i.e. sum of products)
+  //! @ingroup  reductions
+  //! @brief    Computes inner product (i.e. sum of products)
   //!
   //! Computes the generalized sum of products of the elements of two product types. By default,
   //! `+` and `*` is used.
   //!
-  //! On record types, operates by pair of fields sharing the same name.
+  //! On record types, operates by pair of fields sharing the same label.
   //!
   //! @note Does not participate in overload resolution if product types' size are not equal or if any of
   //!       the binary operations can't be applied on the product types' elements. Similarily, doesn't participate