It is probably best to let append functions return void, so that it can be a list of indices in future versions.

Author: Dawoodoz

Source/DFPSR/api/algorithmAPI_List.h

@@ -504,43 +504,38 @@ static inline intptr_t list_insert_unique_sorted_descending(
 	return list_insert_unique_sorted<T>(targetList, element, [](const T &leftSide, const T &rightSide) -> bool { return leftSide >= rightSide; }, compareEqual);
 }
 
-// TODO: Should a list of new indices by returned instead of bool?
-// TODO: Create a varargs version starting with nothing and adding unique elements from all lists before returning by value, so that duplicates in the first list are also reduced.
-// TODO: Take a function for equality.
+// TODO: Create a varargs union function, starting with nothing and adding unique elements from all lists before returning by value, so that duplicates in the first list are also reduced.
+
 // Pre-conditions:
 //   * All elements in targetList must be unique, or else they will remain duplicated.
 //   * targetList and sourceList may not refer to the same list.
 // Pushes all elements in sourceList that does not already exist in targetList.
-// Returns true iff any element was pushed to targetList.
 template <typename T>
-static inline bool list_append_unique_last(dsr::List<T> &targetList, const dsr::List<T> &sourceList) {
-	bool result = false;
+static inline void list_append_unique_last(
+  dsr::List<T> &targetList,
+  const dsr::List<T> &sourceList,
+  const TemporaryCallback<bool(const T &leftSide, const T &rightSide)> &compareEqual = [](const T &leftSide, const T &rightSide) -> bool { return leftSide == rightSide; }
+) {
 	for (intptr_t e = 0; e < sourceList.length(); e++) {
-		// Must store the result in a new variable to avoid lazy evaluation with side-effects.
-		bool newResult = list_insert_unique_last<T>(targetList, sourceList[e]) != -1;
-		result = result || newResult;
+		list_insert_unique_last<T>(targetList, sourceList[e], compareEqual);
 	}
-	return result;
 }
 
-// TODO: Create a varargs version starting with nothing and adding unique elements from all lists before returning by value, so that duplicates in the first list are also reduced.
-// TODO: Take functions for both equality and sorting.
-// TODO: Assert that the original list is sorted in debug mode.
 // Pre-conditions:
 //   All elements in targetList must be unique, or else they will remain duplicated.
 //   targetList must be sorted in ascending order.
 //   targetList and sourceList may not refer to the same list.
 // Pushes all elements in sourceList that does not already exist in targetList.
 // Returns true iff any element was pushed to targetList.
 template <typename T>
-static inline bool list_append_unique_sorted_ascending(dsr::List<T> &targetList, const dsr::List<T> &sourceList) {
-	bool result = false;
+static inline void list_append_unique_sorted_ascending(
+  dsr::List<T> &targetList,
+  const dsr::List<T> &sourceList,
+  const TemporaryCallback<bool(const T &leftSide, const T &rightSide)> &compareEqual = [](const T &leftSide, const T &rightSide) -> bool { return leftSide == rightSide; }
+) {
 	for (intptr_t e = 0; e < sourceList.length(); e++) {
-		// Must store the result in a new variable to avoid lazy evaluation with side-effects.
-		bool newResult = list_insert_unique_sorted_ascending<T>(targetList, sourceList[e]) != -1;
-		result = result || newResult;
+		list_insert_unique_sorted_ascending<T>(targetList, sourceList[e], compareEqual);
 	}
-	return result;
 }
 
 // Pre-conditions:
@@ -550,14 +545,14 @@ static inline bool list_append_unique_sorted_ascending(dsr::List<T> &targetList,
 // Pushes all elements in sourceList that does not already exist in targetList.
 // Returns true iff any element was pushed to targetList.
 template <typename T>
-static inline bool list_append_unique_sorted_descending(dsr::List<T> &targetList, const dsr::List<T> &sourceList) {
-	bool result = false;
+static inline void list_append_unique_sorted_descending(
+  dsr::List<T> &targetList,
+  const dsr::List<T> &sourceList,
+  const TemporaryCallback<bool(const T &leftSide, const T &rightSide)> &compareEqual = [](const T &leftSide, const T &rightSide) -> bool { return leftSide == rightSide; }
+) {
 	for (intptr_t e = 0; e < sourceList.length(); e++) {
-		// Must store the result in a new variable to avoid lazy evaluation with side-effects.
-		bool newResult = list_insert_unique_sorted_descending<T>(targetList, sourceList[e]) != -1;
-		result = result || newResult;
+		list_insert_unique_sorted_descending<T>(targetList, sourceList[e], compareEqual);
 	}
-	return result;
 }
 
 // Helper function for heapSort.

Source/test/tests/ListAlgorithmTest.cpp

@@ -202,10 +202,10 @@ START_TEST(ListAlgorithm)
 	{
 		List<int32_t> unsortedUnion(7, 5, 2, 4);
 		// Nothing is inserted, because all inserted elements already exist.
-		ASSERT_EQUAL(list_append_unique_last(unsortedUnion, List<int32_t>(5, 2)), false);
+		list_append_unique_last(unsortedUnion, List<int32_t>(5, 2));
 		ASSERT_EQUAL(unsortedUnion, List<int32_t>(7, 5, 2, 4));
 		// Unique values (3 and 6) are inserted at the end.
-		ASSERT_EQUAL(list_append_unique_last(unsortedUnion, List<int32_t>(3, 5, 6)), true);
+		list_append_unique_last(unsortedUnion, List<int32_t>(3, 5, 6));
 		ASSERT_EQUAL(unsortedUnion, List<int32_t>(7, 5, 2, 4, 3, 6));
 	}
 	{
@@ -231,10 +231,10 @@ START_TEST(ListAlgorithm)
 	{ // Sorted unions, which are useful for comparing if two sets contain the same values.
 		List<int32_t> sortedUnion(2, 4, 5, 7);
 		// Nothing is inserted, because all inserted elements already exist.
-		ASSERT_EQUAL(list_append_unique_sorted_ascending(sortedUnion, List<int32_t>(5, 2)), false);
+		list_append_unique_sorted_ascending(sortedUnion, List<int32_t>(5, 2));
 		ASSERT_EQUAL(sortedUnion, List<int32_t>(2, 4, 5, 7));
 		// Unique values (3 and 6) are inserted in ascending order.
-		ASSERT_EQUAL(list_append_unique_sorted_ascending(sortedUnion, List<int32_t>(3, 5, 6)), true);
+		list_append_unique_sorted_ascending(sortedUnion, List<int32_t>(3, 5, 6));
 		ASSERT_EQUAL(sortedUnion, List<int32_t>(2, 3, 4, 5, 6, 7));
 	}
 	// TODO: Test with custom comparison functions.