Merge branch 'develop' into feature/fmt_join

Author: bigerl

README.md

@@ -10,9 +10,10 @@ It contains:
 - `for_{types,values,range}`: Compile time for loops for types, values or ranges
 - `polymorphic_allocator`: Like `std::pmr::polymorphic_allocator` but with static dispatch
 - `limit_allocator`: Allocator wrapper that limits the amount of memory that is allowed to be allocated
+- `DICE_MEMFN`: Macro to pass member functions like free functions as argument. 
 - `pool` & `pool_allocator`: Arena/pool allocator optimized for a limited number of known allocation sizes.
 - `DICE_DEFER`/`DICE_DEFER_TO_SUCCES`/`DICE_DEFER_TO_FAIL`: On-the-fly RAII for types that do not support it natively (similar to go's `defer` keyword)
-- `overloaded`: Composition for `std::variant` visitor lambdas
+- `overloaded` and `match`: Batteries for `std::variant` (and also `dtl::variant2`. Compose re-usable visitors with `overload` or apply a single-use visitor directly with `match`.
 - `flex_array`: A combination of `std::array`, `std::span` and a `vector` with small buffer optimization
 - `tuple_algorithms`: Some algorithms for iterating tuples
 - `fmt_join`: A helper to join elements of a range with a separator for use with `std::format` alike [fmt::join](https://fmt.dev/latest/api/#range-and-tuple-formatting)
@@ -73,6 +74,11 @@ Which means: vtables will not work (because they use absolute pointers) and ther
 Allocator wrapper that limits the amount of memory that can be allocated through the inner allocator.
 If the limit is exceeded it will throw `std::bad_alloc`.
 
+### `DICE_MEMFN`
+DICE_MEMFN is a convenience macro that makes it easy to pass member functions as argument, e.g., to range adaptors.
+It eliminates boilerplate code by creating a lambda that captures this and perfectly forwards
+arguments to your member function.
+
 ### `pool_allocator`
 A memory arena/pool allocator with configurable allocation sizes. This is implemented
 as a collection of pools with varying allocation sizes. Allocations that do not
@@ -83,7 +89,7 @@ A mechanism similar to go's `defer` keyword, which can be used to defer some act
 The primary use-case for this is on-the-fly RAII-like resource management for types that do not support RAII (for example C types).
 Usage examples can be found [here](examples/examples_defer.cpp).
 
-### `tuple algorthims`
+### `tuple algorithms`
 Some algorithms for iterating tuples, for example `tuple_fold` a fold/reduce implementation for tuples.
 
 ### `fmt_join`
@@ -109,6 +115,9 @@ Like `std::variant` but specifically optimized for usage with two types/variants
 The internal representation is a `union` of the two types plus a 1 byte (3 state) discriminant.
 Additionally, `visit` does not involve any virtual function calls.
 
+### `overload` / `match`
+Things that are missing around `std::variant` and visitors in the standard library. Implementation of the common `overload` pattern to create re-usable visitors. Also, comes with a `match` function that allows you to declare the visitor directly  inline when applying it. 
+
 ### `type_traits.hpp`
 Things that are missing in the standard library `<type_traits>` header.
 

examples/CMakeLists.txt

@@ -94,6 +94,13 @@ target_link_libraries(example_limit_allocator
         dice-template-library::dice-template-library
 )
 
+add_executable(example_memfn
+        example_memfn.cpp)
+target_link_libraries(example_memfn
+        PRIVATE
+        dice-template-library::dice-template-library
+)
+
 add_executable(example_pool_allocator
         example_pool_allocator.cpp)
 target_link_libraries(example_pool_allocator

examples/example_memfn.cpp

@@ -0,0 +1,31 @@
+#include <algorithm>
+#include <dice/template-library/memfn.hpp>
+
+#include <cassert>
+#include <ranges>
+#include <string>
+#include <vector>
+
+struct NumberProcessor {
+	std::vector<int> numbers_ = {1, 2, 3, 4, 5, 6, 7, 8};
+	std::string prefix_ = "item-";
+	int divisor_ = 2;
+
+	[[nodiscard]] bool has_divisor(int n) const { return n % divisor_ == 0; }
+
+	[[nodiscard]] std::string decorate(int n) const { return prefix_ + std::to_string(n); }
+
+	void example() {
+		auto processed_view = numbers_ |
+							  std::views::filter(DICE_MEMFN(has_divisor)) |
+							  std::views::transform(DICE_MEMFN(decorate));
+
+		assert(std::ranges::equal(processed_view, std::vector<std::string>{"item-2", "item-4", "item-6", "item-8"}));
+	}
+};
+
+int main() {
+	NumberProcessor processor;
+	processor.example();
+	return 0;
+}

examples/example_variant2.cpp

@@ -1,6 +1,8 @@
 #include <cassert>
 #include <string>
+#include <variant>
 
+#include <dice/template-library/overloaded.hpp>
 #include <dice/template-library/variant2.hpp>
 
 namespace dtl = dice::template_library;
@@ -12,30 +14,36 @@ int main() {
 	dtl::variant2<int, float> v;
 	dtl::variant2<int, float> w;
 
-	v = 42; // v contains int
+	v = 42;// v contains int
 	int i = dtl::get<int>(v);
-	assert(42 == i); // succeeds
+	assert(42 == i);// succeeds
 	w = dtl::get<int>(v);
-	w = dtl::get<0>(v); // same effect as the previous line
-	w = v; // same effect as the previous line
+	w = dtl::get<0>(v);// same effect as the previous line
+	w = v;             // same effect as the previous line
 
 	//  dtl::get<double>(v); // error: no double in [int, float]
 	//  dtl::get<3>(v);      // error: valid index values are 0 and 1
 
 	try {
-		(void) dtl::get<float>(w); // w contains int, not float: will throw
-	}
-	catch (dtl::bad_variant_access const &ex) {
+		(void) dtl::get<float>(w);// w contains int, not float: will throw
+	} catch (dtl::bad_variant_access const &ex) {
 		assert(ex.what() == "bad variant access"s);
 	}
 
 	dtl::variant<std::string> x("abc");
 	// converting constructors work when unambiguous
-	x = "def"; // converting assignment also works when unambiguous
+	x = "def";// converting assignment also works when unambiguous
 
-	dtl::variant<std::string, void const*> y("abc");
+	dtl::variant<std::string, void const *> y("abc");
 	// casts to void const* when passed a char const*
-	assert(dtl::holds_alternative<void const*>(y)); // succeeds
+	assert(dtl::holds_alternative<void const *>(y));// succeeds
 	y = "xyz"s;
-	assert(dtl::holds_alternative<std::string>(y)); // succeeds
+	assert(dtl::holds_alternative<std::string>(y));// succeeds
+
+	auto visitor = dtl::overloaded{
+			[](int x) { return x; },
+			[](double d) { return static_cast<int>(d); }};
+
+	auto z = dtl::visit(visitor, v);
+	assert(z == 42);
 }

examples/examples_overloaded.cpp

@@ -1,21 +1,24 @@
 #include <dice/template-library/overloaded.hpp>
+#include <dice/template-library/variant2.hpp>
 
 #include <cassert>
 #include <string>
 #include <variant>
 
+namespace dtl = dice::template_library;
+
+
 int main() {
-	auto visitor = dice::template_library::overloaded{
-		[](int i) {
-			return "Got an int: " + std::to_string(i);
-		},
-		[](std::string s) {
-			return "Got a string: " + s;
-		},
-		[]([[maybe_unused]] auto u) {
-			return std::string{"Got something else"};
-		}
-	};
+	auto visitor = dtl::overloaded{
+			[](int i) {
+				return "Got an int: " + std::to_string(i);
+			},
+			[](std::string s) {
+				return "Got a string: " + s;
+			},
+			[]([[maybe_unused]] auto u) {
+				return std::string{"Got something else"};
+			}};
 
 	std::variant<std::string, int, double> v = "Hello World";
 	auto r1 = std::visit(visitor, v);
@@ -28,4 +31,25 @@ int main() {
 	v = 5.0;
 	auto r3 = std::visit(visitor, v);
 	assert(r3 == "Got something else");
+
+	// Using match for single-use visitors
+	auto r4 = dtl::match(
+			v,
+			[](int x) { return x; },
+			[](double d) { return static_cast<int>(d); },
+			[]([[maybe_unused]] auto f) { return 0; });
+	assert(r4 == 5);
+
+	// also works with variant2
+	dtl::variant2<int, double> v2 = 42.3;
+	auto r5 = dtl::visit(visitor, v2);
+	assert(r5 == "Got something else");
+
+	auto r6 = dice::template_library::match(
+			v2,
+			[](int x) { return x; },
+			[](double d) { return static_cast<int>(d); },
+			[]([[maybe_unused]] auto f) { return 0; });
+	assert(r6 == 42);
+	return 0;
 }

include/dice/template-library/memfn.hpp

@@ -0,0 +1,18 @@
+#ifndef DICE_TEMPLATE_LIBRARY_MEMFN_HPP
+#define DICE_TEMPLATE_LIBRARY_MEMFN_HPP
+
+#include <utility>
+
+/**
+ * @brief Creates a lambda that calls a member function on the current object. Arguments, if any are required, are forwarded.
+ *
+ * @param member_func The name of the member function to call. They are captured from the context.
+ * @param ...args A list of arguments to pass to the call. These bind to the arguments at the front.
+ * @param ...runtime_args Some functions, like range_adaptors, pass in an element. This is used to capture that. Binds to arguments after ...args
+ *
+ */
+#define DICE_MEMFN(member_func, ...)                                                                     \
+	([&, this]<typename... RuntimeArgs>(RuntimeArgs &&...runtime_args) -> decltype(auto) {               \
+		return this->member_func(__VA_ARGS__ __VA_OPT__(, ) std::forward<RuntimeArgs>(runtime_args)...); \
+	})
+#endif// DICE_TEMPLATE_LIBRARY_MEMFN_HPP

tests/CMakeLists.txt

@@ -70,6 +70,9 @@ custom_add_test(tests_type_traits)
 add_executable(tests_limit_allocator tests_limit_allocator.cpp)
 custom_add_test(tests_limit_allocator)
 
+add_executable(tests_memfn tests_memfn.cpp)
+custom_add_test(tests_memfn)
+
 add_executable(tests_pool_allocator tests_pool_allocator.cpp)
 custom_add_test(tests_pool_allocator)
 

tests/tests_memfn.cpp

@@ -0,0 +1,147 @@
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include <doctest/doctest.h>
+
+#include <dice/template-library/memfn.hpp>
+
+#include <algorithm>
+#include <ranges>
+#include <string>
+#include <utility>
+#include <vector>
+
+TEST_SUITE("DICE_MEMFN Argument Forwarding") {
+
+	struct AbstractFixture {
+		enum struct CallSignature : uint8_t {
+			None,
+			ByValue,
+			ByConstLvalueRef,
+			ByLvalueRef,
+			ByRvalueRef,
+			MixedArgs,
+			RangeTransform
+		};
+		CallSignature last_call = CallSignature::None;
+		std::string moved_in_data;
+
+		// Member functions to be called by the macro
+		void process_by_value(std::string s) { last_call = CallSignature::ByValue; }
+		void process_by_const_lvalue_ref(std::string const &s) { last_call = CallSignature::ByConstLvalueRef; }
+		void process_by_lvalue_ref(std::string &s) {
+			last_call = CallSignature::ByLvalueRef;
+			s += "_modified";
+		}
+		void process_by_rvalue_ref(std::string &&s) {
+			last_call = CallSignature::ByRvalueRef;
+			moved_in_data = std::move(s);
+		}
+		void process_mixed_args(std::string const &s_value, std::string const &s_const_ref, int &i_ref) {
+			last_call = CallSignature::MixedArgs;
+			i_ref *= 2;
+			moved_in_data = s_const_ref + "_" + s_value;
+		}
+		std::string transform_int_to_string(std::string const &prefix, int i) {
+			last_call = CallSignature::RangeTransform;
+			return prefix + std::to_string(i);
+		}
+
+
+		// methods for the tests
+		void run_const_lvalue_ref_test() {
+			std::string const data = "immutable";
+			auto task = DICE_MEMFN(process_by_const_lvalue_ref);
+			task(data);
+			CHECK(last_call == CallSignature::ByConstLvalueRef);
+		}
+
+		void run_lvalue_ref_test() {
+			std::string data = "mutable";
+			auto task = DICE_MEMFN(process_by_lvalue_ref);
+			task(data);
+			CHECK(last_call == CallSignature::ByLvalueRef);
+			CHECK(data == "mutable_modified");
+		}
+
+		void run_rvalue_ref_test() {
+			std::string data = "movable";
+			auto task = DICE_MEMFN(process_by_rvalue_ref);
+			task(std::move(data));
+			CHECK(last_call == CallSignature::ByRvalueRef);
+			CHECK(moved_in_data == "movable");
+			CHECK(data.empty());
+		}
+
+		void run_by_value_test() {
+			std::string data = "copyable";
+			auto task = DICE_MEMFN(process_by_value);
+
+			task(data);
+			CHECK(last_call == CallSignature::ByValue);
+			CHECK(data == "copyable");
+
+			task("temporary");
+			CHECK(last_call == CallSignature::ByValue);
+		}
+
+		void run_mixed_args_test() {
+			std::string const const_data = "hello";
+			int mutable_int = 10;
+			std::string movable_data = "world";
+
+			auto task = DICE_MEMFN(process_mixed_args, movable_data);
+			task(const_data, mutable_int);
+
+			CHECK(last_call == CallSignature::MixedArgs);
+			CHECK(mutable_int == 20);
+			CHECK(moved_in_data == "hello_world");
+			CHECK_FALSE(movable_data.empty());
+		}
+
+		void run_range_adaptor_test() {
+			std::vector<int> source_data = {10, 20, 30};
+			std::string const prefix = "item_";
+
+			auto transformed_view = source_data | std::views::transform(DICE_MEMFN(transform_int_to_string, prefix));
+
+			std::vector<std::string> results;
+			std::ranges::copy(transformed_view, std::back_inserter(results));
+
+			CHECK(last_call == CallSignature::RangeTransform);
+
+			CHECK(results.size() == 3);
+			CHECK(results[0] == "item_10");
+			CHECK(results[1] == "item_20");
+			CHECK(results[2] == "item_30");
+		}
+	};
+
+	TEST_CASE("Forwards arguments as const lvalue references") {
+		AbstractFixture f;
+		f.run_const_lvalue_ref_test();
+	}
+
+	TEST_CASE("Forwards arguments as non-const lvalue references") {
+		AbstractFixture f;
+		f.run_lvalue_ref_test();
+	}
+
+	TEST_CASE("Forwards arguments as rvalue references") {
+		AbstractFixture f;
+		f.run_rvalue_ref_test();
+	}
+
+	TEST_CASE("Forwards arguments by value") {
+		AbstractFixture f;
+		f.run_by_value_test();
+	}
+
+	TEST_CASE("Forwards mixed arguments with pre-binding") {
+		AbstractFixture f;
+		f.run_mixed_args_test();
+	}
+
+	TEST_CASE("Usage with a range adaptor") {
+		AbstractFixture f;
+		f.run_range_adaptor_test();
+	}
+}