Should be mergeable

Author: Nxirda

doc/Doxyfile

@@ -439,7 +439,7 @@ GROUP_NESTED_COMPOUNDS = NO
 # \nosubgrouping command.
 # The default value is: YES.
 
-SUBGROUPING            = YES
+SUBGROUPING            = NO
 
 # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
 # are shown inside the group in which they are included (e.g. using \ingroup)

doc/index.hpp

@@ -7,11 +7,11 @@
 //! `std::tuple` as possible but also wants to compile faster, uses a better C++20 oriented interface,
 //! and new features like:
 //!
-//!   -  a fast to compile tuple implementation
-//!   -  quality of life improvement over the standard tuple implementation
-//!   -  a protocol to adapt user-defined type to act as tuples
-//!   -  algorithm on tuples
-//!   -  record type handling
+//!   -  A fast to compile tuple implementation
+//!   -  Quality of life improvement over the standard tuple implementation
+//!   -  A protocol to adapt user-defined type to act as tuples
+//!   -  Algorithm on tuples
+//!   -  Record type handling
 //!
 //! # Examples
 //!
@@ -33,9 +33,9 @@
 //!   auto student0 = get_student(0);
 //!
 //!   std::cout << "ID: 0, "
-//!             << "GPA: "    << kumi::get<0>(student0) << ", "
-//!             << "grade: "  << kumi::get<1>(student0) << ", "
-//!             << "name: "   << kumi::get<2>(student0) << '\n';
+//!             << "GPA:   " << kumi::get<0>(student0) << ", "
+//!             << "grade: " << kumi::get<1>(student0) << ", "
+//!             << "name:  " << kumi::get<2>(student0) << '\n';
 //!
 //!   auto [ gpa1, grade1, name1 ] = get_student(1);
 //!   std::cout << "ID: 1, "
@@ -46,7 +46,9 @@
 //!
 //!   auto all_students = kumi::make_tuple(get_student(0),get_student(1),get_student(2));
 //!
-//!   kumi::for_each_index( [](auto i, auto const& m) { std::cout << "Data #" << i << " : " << m << "\n";}
+//!   kumi::for_each_index( [](auto i, auto const& m) { 
+//!                         std::cout << "Data #" << i << " : " << m << "\n";
+//!                       }
 //!                       , all_students
 //!                       );
 //!   std::cout << "\n";
@@ -75,7 +77,7 @@
 //!   auto student0 = get_student(0);
 //!
 //!   std::cout << "ID: 0, "
-//!             << "GPA: "    << kumi::get<"GPA"_f>(student0)   << ", "
+//!             << "GPA:   "  << kumi::get<"GPA"_f>(student0)   << ", "
 //!             << "grade: "  << kumi::get<"grade"_f>(student0) << '\n';
 //!
 //!   auto [ gpa1, grade1 ] = get_student(1);
@@ -90,7 +92,9 @@
 //!                       "Ralph Wiggum"_f        = get_student(2)
 //!                       );
 //!
-//!   kumi::for_each_field( [](auto name, auto const& m) { std::cout << "Student: " << name << ", Data : " << m << "\n";}
+//!   kumi::for_each_field( [](auto name, auto const& m) { 
+//!                         std::cout << "Student: " << name << ", Data : " << m << "\n";
+//!                       }
 //!                       , all_students
 //!                       );
 //!   std::cout << "\n";

doc/licence.md

@@ -3,7 +3,7 @@ Licence {#licence}
 
 This library is licensed under the [Boost Software License](http://opensource.org/licenses/MIT):
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ none
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~none
 Copyright : KUMI Project Contributors
 
 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the

doc/setup.hpp

@@ -5,9 +5,10 @@
   @page  setup  Setup
 
   @tableofcontents
+
   @section prerequisit Pre-requisites
 
-  **KUMI** requires a C++20 compliant compiler. Here is the current minimal compiler version supported:
+  The **KUMI** librarie requires a C++20 compliant compiler. Here are the current minimal compiler version supported:
 
   | Compiler       | Version        |
   | -------------- | -------------- |

include/kumi/algorithm.hpp

@@ -11,18 +11,21 @@ namespace kumi
 {
   //================================================================================================
   //! @defgroup algorithm Product Type Algorithms
-  //! @brief    Algorithms for manipulating kumi::product_type
+  //! @brief    Algorithms for manipulating Product types
   //!
   //! @addtogroup algorithm
   //! @{
   //!   @defgroup transforms Product Type Transformations
-  //!   @brief    Algorithms applying transformation to product types
-  //!
-  //!   @defgroup tuple_transforms Tuple Type Specific Transformations
-  //!   @brief    Algorithms applying transformation to tuples
-  //!
-  //!   @defgroup record_transforms Record Type Specific Transformations
-  //!   @brief    Algorithms applying transformation to records
+  //!   @brief Algorithms applying transformation to product types
+  //! 
+  //!   @addtogroup transforms
+  //!   @{  
+  //!     @defgroup tuple_transforms Tuple Type Specific Transformations
+  //!     @brief Algorithms applying transformation to tuples
+  //!   
+  //!     @defgroup record_transforms Record Type Specific Transformations
+  //!     @brief Algorithms applying transformation to records  
+  //!   @}   
   //!
   //!   @defgroup queries Product Type Queries
   //!   @brief    Algorithms querying properties from product types

include/kumi/algorithm/back-front.hpp

@@ -12,7 +12,7 @@
 namespace kumi
 {
   //================================================================================================
-  //! @ingroup utility
+  //! @ingroup queries 
   //! @brief Retrieves the front of a product type
   //!
   //! @param t Base product type
@@ -42,7 +42,7 @@ namespace kumi
   }
 
   //================================================================================================
-  //! @ingroup utility
+  //! @ingroup queries 
   //! @brief Retrieves the back of a product type
   //!
   //! @param t Base product type

include/kumi/algorithm/cat.hpp

@@ -16,7 +16,7 @@ namespace kumi
   //! @brief Concatenates product types in a single one
   //!
   //! @param ts Product types to concatenate
-  //! @return   A product type made of all element of all input product types in order
+  //! @return   A product type made of all element of all input product types in order.
   //!
   //! ## Helper type
   //! @code

include/kumi/algorithm/extract.hpp

@@ -21,7 +21,7 @@ namespace kumi
   //! @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 kumi::tuple containing to the selected elements of the input tuple.
+  //! @return A new product type containing to the selected elements of the input tuple.
   //!
   //! ## Helper type
   //! @code
@@ -38,6 +38,7 @@ namespace kumi
   //!
   //! ## Example:
   //! @include doc/extract.cpp
+  //! @include doc/record/extract.cpp
   //================================================================================================
   template<std::size_t I0, std::size_t I1, product_type T>
   requires( (I0 <= size_v<T>) && (I1 <= size_v<T>) )
@@ -57,7 +58,7 @@ namespace kumi
 
   //! @overload
   template<std::size_t I0, product_type T>
-  requires(I0 <= size_v<T>)
+  requires( I0 <= size_v<T> )
   [[nodiscard]] KUMI_ABI constexpr auto extract(T && t, index_t<I0> i0) noexcept
   {
     return extract(KUMI_FWD(t), i0, index<size_v<T>>);
@@ -67,14 +68,14 @@ namespace kumi
   //! @ingroup generators
   //! @brief Split a product type into two
   //!
-  //! Split a @ref kumi::product_type in two kumi::product_type containing all the elements before
+  //! Split a product type in two product_type containing all the elements before
   //! and after a given index.
   //!
   //! @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 kumi::tuple containing the two sub product types cut at index I.
+  //! @return A new tuple containing the two sub product types cut at index I.
   //!
   //! ## Helper type
   //! @code
@@ -94,7 +95,7 @@ namespace kumi
   //! @include doc/record/split.cpp
   //================================================================================================
   template<std::size_t I0, product_type T>
-  requires(I0 <= size_v<T>)
+  requires( I0 <= size_v<T> )
   [[nodiscard]] KUMI_ABI constexpr auto split( T && t
                                     , [[maybe_unused]] index_t<I0> i0
                                     ) noexcept

include/kumi/algorithm/find.hpp

@@ -16,8 +16,10 @@ namespace kumi
   //! @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<tuple<T...>>::value otherwise.
+  //!
   //! ## Example:
   //! @include doc/locate.cpp
+  //! @include doc/record/locate.cpp
   //================================================================================================
   template<typename Pred, product_type T>
   [[nodiscard]] KUMI_ABI constexpr auto locate( T && t, Pred p ) noexcept

include/kumi/algorithm/flatten.hpp

@@ -113,6 +113,7 @@ namespace kumi
   //!
   //! ## Example
   //! @include doc/flatten.cpp
+  //! @include doc/record/flatten.cpp
   //================================================================================================
   template<product_type T> [[nodiscard]] KUMI_ABI constexpr auto flatten(T && t)
   {
@@ -166,6 +167,7 @@ namespace kumi
   //!
   //! ## Example
   //! @include doc/flatten_all.cpp
+  //! @include doc/record/flatten_all.cpp
   //================================================================================================
   template<product_type T, typename Func>
   [[nodiscard]] KUMI_ABI constexpr auto flatten_all(T && t, Func && f)