merge develop

Author: liss-h

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.24)
 
 project(
   dice-template-library
-  VERSION 1.18.0
+  VERSION 1.19.0
   DESCRIPTION
     "This template library is a collection of template-oriented code that we, the Data Science Group at UPB, found pretty handy. It contains: `switch_cases` (Use runtime values in compile-time context), `integral_template_tuple` (Create a tuple-like structure that instantiates a template for a range of values), `integral_template_variant` (A wrapper type for `std::variant` guarantees to only contain variants of the form `T<IX>` and `for_{types,values,range}` (Compile time for loops for types, values or ranges))."
   HOMEPAGE_URL "https://dice-research.org/")

README.md

@@ -167,7 +167,7 @@ A C++20 compatible compiler. Code was only tested on x86_64.
 ## Include it in your projects
 ### Conan
 You can use it with [conan](https://conan.io/).
-To do so, you need to add `dice-template-library/1.18.0` to the `[requires]` section of your conan file.
+To do so, you need to add `dice-template-library/1.19.0` to the `[requires]` section of your conan file.
 
 ## Build and Run Tests and Examples
 

include/dice/template-library/ranges.hpp

@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <limits>
 #include <ranges>
 #include <set>
 #include <unordered_set>
@@ -320,39 +321,76 @@ namespace dice::template_library {
 
 
 namespace dice::template_library {
+
+	template<typename S, typename T>
+	concept step_for = std::is_default_constructible_v<S> && requires (T start, T const stop, S step) {
+		{ start <= stop } -> std::convertible_to<bool>;
+		{ start >= stop } -> std::convertible_to<bool>;
+
+		start += step;
+	};
+
 	namespace ranges_algo_detail {
 
 		// The view that represents the generated sequence.
 		// range generator view (python-like iota with step)
-		template<std::integral T>
-		struct range_generator_view : std::ranges::view_interface<range_generator_view<T>> {
+		template<typename T, step_for<T> S>
+		struct range_generator_view : std::ranges::view_interface<range_generator_view<T, S>> {
 			struct iterator;
 			using sentinel = std::default_sentinel_t;
 
 		private:
 			T start_;
 			T stop_;
-			std::make_signed_t<T> step_;
+			S step_;
 
 		public:
-			explicit constexpr range_generator_view(T start, T stop, std::make_signed_t<T> step) noexcept
+			explicit constexpr range_generator_view(T start, T stop, S step)
 				: start_{start},
 				  stop_{stop},
 				  step_{step} {
+
+				if (step == S{}) [[unlikely]] {
+					throw std::invalid_argument{"range: step must not be the zero element/the additive identity"};
+				}
 			}
 
 			constexpr iterator begin() const noexcept {
 				return iterator{*this, start_};
 			}
 
-			constexpr sentinel end() const noexcept {
+			static constexpr sentinel end() noexcept {
 				return std::default_sentinel;
 			}
+
+			constexpr size_t size() const noexcept requires (std::integral<T> && std::integral<S>) {
+				// Math for calculating result: ceil(|stop_ - start_| / |step_|)
+				// For integers we need to adjust the formula to avoid overflows, conversions and inefficient operations.
+				// Note: ceil(a / b) = (a + b - 1) / b
+
+				if (start_ <= stop_) {
+					// forward
+					if (step_ < 0) {
+						// wrong direction
+						return 0;
+					}
+
+					return (stop_ - start_ + step_ - 1) / step_;
+				} else {
+					// backward
+					if (step_ > 0) {
+						// wrong direction
+						return 0;
+					}
+
+					return (start_ - stop_ + -step_ - 1) / -step_;
+				}
+			}
 		};
 
 		// The iterator that generates the numbers on the fly.
-		template<std::integral T>
-		struct range_generator_view<T>::iterator {
+		template<typename T, step_for<T> S>
+		struct range_generator_view<T, S>::iterator {
 			using iterator_category = std::input_iterator_tag;
 			using value_type = T;
 			using difference_type = std::ptrdiff_t;
@@ -382,7 +420,7 @@ namespace dice::template_library {
 			friend constexpr bool operator==(iterator const &self, std::default_sentinel_t) noexcept {
 				// The end is reached if the step is positive and value is >= stop,
 				// or if the step is negative and value is <= stop.
-				if (self.parent_->step_ > 0) {
+				if (self.parent_->step_ > S{}) {
 					return self.value_ >= self.parent_->stop_;
 				}
 				return self.value_ <= self.parent_->stop_;
@@ -402,20 +440,19 @@ namespace dice::template_library {
 	 * - `range<T>(start, stop)`: Generates [start,stop).
 	 * - `range<T>(start, stop, step)`: Generates numbers from start, incrementing by step, until stop is met or passed.
 	 */
-	template<std::integral T, typename S = T>
+	template<typename T, typename S>
 	constexpr auto range(T start, T stop, S step) noexcept {
-		static_assert(std::is_integral_v<S>, "Step must be an integral type.");
-		return ranges_algo_detail::range_generator_view<T>(start, stop, static_cast<std::make_signed_t<T>>(step));
+		return ranges_algo_detail::range_generator_view<T, S>(start, stop, step);
 	}
 
-	template<std::integral T>
+	template<typename T> requires (std::is_constructible_v<T, int> && step_for<T, T>)
 	constexpr auto range(T start, T stop) noexcept {
-		return ranges_algo_detail::range_generator_view<T>(start, stop, 1);
+		return ranges_algo_detail::range_generator_view<T, T>(start, stop, T(1));
 	}
 
-	template<std::integral T>
+	template<typename T> requires (std::is_default_constructible_v<T> && std::is_constructible_v<T, int>)
 	constexpr auto range(T stop) noexcept {
-		return ranges_algo_detail::range_generator_view<T>(static_cast<T>(0), stop, 1);
+		return ranges_algo_detail::range_generator_view<T, T>(T{}, stop, T(1));
 	}
 
 }// namespace dice::template_library

include/dice/template-library/type_list.hpp

@@ -264,6 +264,35 @@ namespace dice::template_library::type_list {
     using find_if_t = typename find_if<TL, pred>::type;
 
 
+    namespace detail_position {
+        template<typename TL, auto pred, size_t ix>
+        struct position;
+
+        template<auto pred, size_t ix>
+        struct position<type_list<>, pred, ix> {
+        };
+
+        template<typename T, typename ...Ts, auto pred, size_t ix>
+        requires (!std::invoke(pred, std::type_identity<T>{}))
+        struct position<type_list<T, Ts...>, pred, ix> : position<type_list<Ts...>, pred, ix + 1> {
+        };
+
+        template<typename T, typename ...Ts, auto pred, size_t ix>
+        requires (std::invoke(pred, std::type_identity<T>{}))
+        struct position<type_list<T, Ts...>, pred, ix> : std::integral_constant<size_t, ix> {
+        };
+    } // namespace detail_position
+
+    /**
+     * Searches for an element in the type list, returning the first position where the predicate returns true.
+     */
+    template<typename TL, auto pred>
+    using position = detail_position::position<TL, pred, 0>;
+
+    template<typename TL, auto pred>
+    inline constexpr size_t position_v = position<TL, pred>::value;
+
+
 	/**
      * Check if a particular type is present in the type list.
      *
@@ -356,32 +385,70 @@ namespace dice::template_library::type_list {
      * A marker type to indicate a failed operation
      * when using opt
      */
-    struct nullopt {};
+    struct nullopt {
+        constexpr bool operator==(nullopt const &other) const noexcept = default;
+    };
+
+
+    namespace detail_opt {
+
+        template<typename T>
+        concept type_present = requires {
+            typename T::type;
+        };
+
+        template<typename T>
+        concept value_present = requires {
+            T::value;
+        };
+
+    } // namespace detail_opt
 
 	/**
      * Can be used in combination with any operation that may fail.
-     * By default, failing operations will not provide a `type` member typedef.
+     * By default, failing operations will not provide a `type` member typedef / a static constexpr value.
      * When using opt, the member typedef `type` will always be present. In case the operation failed the type will be `nullopt`.
+     * Additionally, the static constexpr value will always be present. In case the operation failed the static constexpr value will be `nullopt{}`
      *
      * @example
      * @code
      * using X = first_t<type_list<>>; // compilation failure, first has no `type` typedef
      * using X = opt_t<first<type_list<>>; // compilation success, X is nullopt
      * @endcode
      */
-    template<typename T, typename = void>
+    template<typename T>
     struct opt {
         using type = nullopt;
+        static constexpr auto value = nullopt{};
+    };
+
+    template<typename T>
+    requires (detail_opt::type_present<T> && !detail_opt::value_present<T>)
+    struct opt<T> {
+        using type = typename T::type;
+        static constexpr auto value = nullopt{};
+    };
+
+    template<typename T>
+    requires (!detail_opt::type_present<T> && detail_opt::value_present<T>)
+    struct opt<T> {
+        using type = nullopt;
+        static constexpr auto value = T::value;
     };
 
     template<typename T>
-    struct opt<T, std::void_t<typename T::type>> {
+    requires (detail_opt::type_present<T> && detail_opt::value_present<T>)
+    struct opt<T> {
         using type = typename T::type;
+        static constexpr auto value = T::value;
     };
 
     template<typename T>
     using opt_t = typename opt<T>::type;
 
+    template<typename T>
+    inline constexpr auto opt_v = opt<T>::value;
+
 
     namespace detail_for_each {
         template<typename ...Ts, typename F>