From eef276572d27a06b3d8701e5f8359980e2dbde81 Mon Sep 17 00:00:00 2001
From: RobinTF <83676088+RobinTF@users.noreply.github.com>
Date: Wed, 12 Feb 2025 16:28:52 +0100
Subject: [PATCH 1/6] Optimize headers even more (#1785)

Follow-up to #1781, eliminates some dead code and optimizes includes again by moving the very expensive include of `RuntimeParameters.h` into the cpp files.
---
 src/engine/CMakeLists.txt            |  3 +-
 src/engine/OptionalJoin.h            | 10 +--
 src/engine/QueryExecutionContext.cpp | 11 ++++
 src/engine/QueryExecutionContext.h   |  9 ++-
 src/engine/QueryExecutionTree.cpp    |  2 +-
 src/global/Id.h                      | 95 +---------------------------
 src/index/VocabularyMerger.h         |  4 +-
 src/util/AllocatorWithLimit.h        |  1 -
 test/CMakeLists.txt                  |  2 -
 test/GroupByTest.cpp                 | 12 ++--
 test/MilestoneIdTest.cpp             | 90 --------------------------
 11 files changed, 29 insertions(+), 210 deletions(-)
 create mode 100644 src/engine/QueryExecutionContext.cpp
 delete mode 100644 test/MilestoneIdTest.cpp

diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
index e81c834303..98faba8743 100644
--- a/src/engine/CMakeLists.txt
+++ b/src/engine/CMakeLists.txt
@@ -14,5 +14,6 @@ add_library(engine
         CartesianProductJoin.cpp TextIndexScanForWord.cpp TextIndexScanForEntity.cpp
         TextLimit.cpp LazyGroupBy.cpp GroupByHashMapOptimization.cpp SpatialJoin.cpp
         CountConnectedSubgraphs.cpp SpatialJoinAlgorithms.cpp PathSearch.cpp ExecuteUpdate.cpp
-        Describe.cpp GraphStoreProtocol.cpp)
+        Describe.cpp GraphStoreProtocol.cpp
+        QueryExecutionContext.cpp)
 qlever_target_link_libraries(engine util index parser sparqlExpressions http SortPerformanceEstimator Boost::iostreams s2)
diff --git a/src/engine/OptionalJoin.h b/src/engine/OptionalJoin.h
index 91d1a502d9..7685bd8708 100644
--- a/src/engine/OptionalJoin.h
+++ b/src/engine/OptionalJoin.h
@@ -58,14 +58,8 @@ class OptionalJoin : public Operation {
     return {_left.get(), _right.get()};
   }
 
-  /**
-   * @brief Joins two result tables on any number of columns, inserting the
-   *        special value ID_NO_VALUE for any entries marked as optional.
-   * @param a
-   * @param b
-   * @param joinColumns
-   * @param result
-   */
+  // Joins two result tables on any number of columns, inserting the special
+  // value `Id::makeUndefined()` for any entries marked as optional.
   void optionalJoin(
       const IdTable& left, const IdTable& right,
       const std::vector<std::array<ColumnIndex, 2>>& joinColumns,
diff --git a/src/engine/QueryExecutionContext.cpp b/src/engine/QueryExecutionContext.cpp
new file mode 100644
index 0000000000..b458206613
--- /dev/null
+++ b/src/engine/QueryExecutionContext.cpp
@@ -0,0 +1,11 @@
+//   Copyright 2025, University of Freiburg,
+//   Chair of Algorithms and Data Structures.
+//   Author: Robin Textor-Falconi <textorr@informatik.uni-freiburg.de>
+
+#include "engine/QueryExecutionContext.h"
+
+#include "global/RuntimeParameters.h"
+
+bool QueryExecutionContext::areWebSocketUpdatesEnabled() {
+  return RuntimeParameters().get<"websocket-updates-enabled">();
+}
diff --git a/src/engine/QueryExecutionContext.h b/src/engine/QueryExecutionContext.h
index 1e891a398f..501f2ba538 100644
--- a/src/engine/QueryExecutionContext.h
+++ b/src/engine/QueryExecutionContext.h
@@ -5,8 +5,6 @@
 
 #pragma once
 
-#include <global/RuntimeParameters.h>
-
 #include <memory>
 #include <string>
 
@@ -19,7 +17,6 @@
 #include "index/Index.h"
 #include "util/Cache.h"
 #include "util/ConcurrentCache.h"
-#include "util/Synchronized.h"
 
 // The value of the `QueryResultCache` below. It consists of a `Result` together
 // with its `RuntimeInfo`.
@@ -151,6 +148,9 @@ class QueryExecutionContext {
     return areWebsocketUpdatesEnabled_;
   }
 
+ private:
+  static bool areWebSocketUpdatesEnabled();
+
  private:
   const Index& _index;
 
@@ -168,6 +168,5 @@ class QueryExecutionContext {
   std::function<void(std::string)> updateCallback_;
   // Cache the state of that runtime parameter to reduce the contention of the
   // mutex.
-  bool areWebsocketUpdatesEnabled_ =
-      RuntimeParameters().get<"websocket-updates-enabled">();
+  bool areWebsocketUpdatesEnabled_ = areWebSocketUpdatesEnabled();
 };
diff --git a/src/engine/QueryExecutionTree.cpp b/src/engine/QueryExecutionTree.cpp
index cef01b1129..79a3783f86 100644
--- a/src/engine/QueryExecutionTree.cpp
+++ b/src/engine/QueryExecutionTree.cpp
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "engine/Sort.h"
-#include "parser/RdfEscaping.h"
+#include "global/RuntimeParameters.h"
 
 using std::string;
 
diff --git a/src/global/Id.h b/src/global/Id.h
index a62cf36142..af93705ba8 100644
--- a/src/global/Id.h
+++ b/src/global/Id.h
@@ -3,16 +3,12 @@
 // Author: Björn Buchhold (buchhold@informatik.uni-freiburg.de)
 #pragma once
 
-#include <absl/strings/str_cat.h>
-
 #include <cstdint>
-#include <limits>
 
 #include "global/ValueId.h"
-#include "util/Exception.h"
 
 using Id = ValueId;
-typedef uint16_t Score;
+using Score = uint16_t;
 
 // TODO<joka921> Make the following ID and index types strong.
 using ColumnIndex = uint64_t;
@@ -23,92 +19,3 @@ using WordIndex = uint64_t;
 using WordOrEntityIndex = uint64_t;
 using TextBlockIndex = uint64_t;
 using CompressionCode = uint64_t;
-
-// Integers, that are probably not integers but strong IDs or indices, but their
-// true nature is still to be discovered.
-using UnknownIndex = uint64_t;
-
-// A value to use when the result should be empty (e.g. due to an optional join)
-// The highest two values are used as sentinels.
-static const Id ID_NO_VALUE = Id::makeUndefined();
-
-namespace ad_utility {
-
-// An exception that is thrown when an integer overflow occurs in the
-// `MilestoneIdManager`
-class MilestoneIdOverflowException : public std::exception {
- private:
-  std::string _message;
-
- public:
-  explicit MilestoneIdOverflowException(std::string message)
-      : _message{std::move(message)} {}
-  [[nodiscard]] const char* what() const noexcept override {
-    return _message.c_str();
-  }
-};
-
-// Manages two kinds of IDs: plain IDs (unsigned 64-bit integers, just called
-// "IDs" in the following), and milestone IDs (unsigned 64-bit integers that are
-// multiples of `distanceBetweenMilestones`. This class has the functionality to
-// find the next milestone of plain ID, to check whether an ID is amilestone ID
-// and to convert milestone IDs from and to a local ID space.
-template <size_t distanceBetweenMilestones>
-class MilestoneIdManager {
- private:
-  // The next free ID;
-  uint64_t _nextId{0};
-  // The last ID that was assigned. Used for overflow detection.
-  uint64_t _previousId{0};
-
- public:
-  MilestoneIdManager() = default;
-
-  // The maximum number of milestone Ids.
-  constexpr static uint64_t numMilestoneIds =
-      std::numeric_limits<uint64_t>::max() / distanceBetweenMilestones;
-
-  // Get the smallest milestone ID that is larger than all (milestone and
-  // non-milestone) previously obtained IDs.
-  uint64_t getNextMilestoneId() {
-    if (!isMilestoneId(_nextId)) {
-      _nextId = (milestoneIdFromLocal(milestoneIdToLocal(_nextId) + 1));
-    }
-    return getNextId();
-  }
-
-  // Get the smallest ID that is larger than all previously obtained IDs.
-  uint64_t getNextId() {
-    if (_nextId < _previousId) {
-      throw MilestoneIdOverflowException{absl::StrCat(
-          "Overflow while assigning Ids from a MilestoneIdManager. The "
-          "previous "
-          "milestone Id was ",
-          _previousId, " the next id would be ", _nextId,
-          ". The maximum number of milestones is ", numMilestoneIds, ".")};
-    }
-    _previousId = _nextId;
-    _nextId++;
-    return _previousId;
-  }
-
-  // Is this ID a milestone id, equivalently: Is this ID a multiple of
-  // `distanceBetweenMilestones`?
-  constexpr static bool isMilestoneId(uint64_t id) {
-    return id % distanceBetweenMilestones == 0;
-  }
-
-  // Convert a milestone ID to its "local" ID by dividing it by
-  // `distanceBetweenMilestones` (the i-th milestone ID will become `i`).
-  constexpr static uint64_t milestoneIdToLocal(uint64_t id) {
-    return id / distanceBetweenMilestones;
-  }
-
-  // Convert "local" ID to milestone ID by multiplying it with
-  // `distanceBetweenMilestones`.
-  constexpr static uint64_t milestoneIdFromLocal(uint64_t id) {
-    return id * distanceBetweenMilestones;
-  }
-};
-
-}  // namespace ad_utility
diff --git a/src/index/VocabularyMerger.h b/src/index/VocabularyMerger.h
index ae72da46c6..0048baea51 100644
--- a/src/index/VocabularyMerger.h
+++ b/src/index/VocabularyMerger.h
@@ -68,8 +68,8 @@ struct VocabularyMetaData {
     bool contains(Id id) const { return begin_ <= id && id < end_; }
 
    private:
-    Id begin_ = ID_NO_VALUE;
-    Id end_ = ID_NO_VALUE;
+    Id begin_ = Id::makeUndefined();
+    Id end_ = Id::makeUndefined();
     std::string prefix_;
     bool beginWasSeen_ = false;
   };
diff --git a/src/util/AllocatorWithLimit.h b/src/util/AllocatorWithLimit.h
index 1a52d0532f..400e30d409 100644
--- a/src/util/AllocatorWithLimit.h
+++ b/src/util/AllocatorWithLimit.h
@@ -7,7 +7,6 @@
 
 #include <absl/strings/str_cat.h>
 
-#include <atomic>
 #include <functional>
 #include <memory>
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 87b80f9fe6..904bd58706 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -254,8 +254,6 @@ addLinkAndDiscoverTest(ContentEncodingHelperTest http)
 
 addLinkAndDiscoverTest(PrefixCompressorTest)
 
-addLinkAndDiscoverTest(MilestoneIdTest)
-
 addLinkAndDiscoverTest(VocabularyTest index)
 
 addLinkAndDiscoverTestNoLibs(IteratorTest)
diff --git a/test/GroupByTest.cpp b/test/GroupByTest.cpp
index a23fef2475..8f89f9ff11 100644
--- a/test/GroupByTest.cpp
+++ b/test/GroupByTest.cpp
@@ -263,9 +263,9 @@ TEST_F(GroupByTest, doGroupBy) {
   ASSERT_EQ(123u, outTable._data[1][9]);
   ASSERT_EQ(0u, outTable._data[2][9]);
 
-  ASSERT_EQ(ID_NO_VALUE, outTable._data[0][10]);
-  ASSERT_EQ(ID_NO_VALUE, outTable._data[1][10]);
-  ASSERT_EQ(ID_NO_VALUE, outTable._data[2][10]);
+  ASSERT_EQ(Id::makeUndefined(), outTable._data[0][10]);
+  ASSERT_EQ(Id::makeUndefined(), outTable._data[1][10]);
+  ASSERT_EQ(Id::makeUndefined(), outTable._data[2][10]);
 
   std::memcpy(&buffer, &outTable._data[0][11], sizeof(float));
   ASSERT_FLOAT_EQ(-3, buffer);
@@ -283,9 +283,9 @@ TEST_F(GroupByTest, doGroupBy) {
   ASSERT_EQ(41223u, outTable._data[1][13]);
   ASSERT_EQ(41223u, outTable._data[2][13]);
 
-  ASSERT_EQ(ID_NO_VALUE, outTable._data[0][14]);
-  ASSERT_EQ(ID_NO_VALUE, outTable._data[1][14]);
-  ASSERT_EQ(ID_NO_VALUE, outTable._data[2][14]);
+  ASSERT_EQ(Id::makeUndefined(), outTable._data[0][14]);
+  ASSERT_EQ(Id::makeUndefined(), outTable._data[1][14]);
+  ASSERT_EQ(Id::makeUndefined(), outTable._data[2][14]);
 
   std::memcpy(&buffer, &outTable._data[0][15], sizeof(float));
   ASSERT_FLOAT_EQ(2, buffer);
diff --git a/test/MilestoneIdTest.cpp b/test/MilestoneIdTest.cpp
deleted file mode 100644
index a13e51bf59..0000000000
--- a/test/MilestoneIdTest.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//  Copyright 2022, University of Freiburg,
-//  Chair of Algorithms and Data Structures.
-//  Author: Johannes Kalmbach <kalmbach@cs.uni-freiburg.de>
-
-#include <gtest/gtest.h>
-
-#include "global/Id.h"
-#include "util/Log.h"
-
-template <uint64_t distance>
-void testMilestoneIds() {
-  ad_utility::MilestoneIdManager<distance> m;
-  for (size_t i = 0; i < distance; ++i) {
-    auto id = m.getNextMilestoneId();
-    ASSERT_EQ(i * distance, id);
-    ASSERT_TRUE(m.isMilestoneId(id));
-    ASSERT_EQ(i, m.milestoneIdToLocal(id));
-    ASSERT_EQ(id, m.milestoneIdFromLocal(m.milestoneIdToLocal(id)));
-  }
-}
-
-TEST(MilestoneId, OnlyMilestoneIds) {
-  testMilestoneIds<256>();
-  testMilestoneIds<257>();
-#ifdef QLEVER_RUN_EXPENSIVE_TESTS
-  testMilestoneIds<1024 * 1024>();
-  testMilestoneIds<1024 * 1024 + 53>();
-#endif
-}
-
-template <uint64_t distance>
-void testConsecutiveIds() {
-  ad_utility::MilestoneIdManager<distance> m;
-  for (size_t i = 0; i < 3 * distance; ++i) {
-    auto id = m.getNextId();
-    ASSERT_EQ(i, id);
-    if (id == 0 || id == distance || id == 2 * distance) {
-      ASSERT_TRUE(m.isMilestoneId(id));
-      ASSERT_EQ(id, m.milestoneIdFromLocal(m.milestoneIdToLocal(id)));
-    } else {
-      ASSERT_FALSE(m.isMilestoneId(id));
-      ASSERT_NE(id, m.milestoneIdFromLocal(m.milestoneIdToLocal(id)));
-    }
-  }
-}
-
-TEST(MilestoneId, ConsecutiveIds) {
-  testConsecutiveIds<256>();
-  testConsecutiveIds<257>();
-
-#ifdef QLEVER_RUN_EXPENSIVE_TESTS
-  testConsecutiveIds<1024 * 1024>();
-  testConsecutiveIds<1024 * 1024 + 53>();
-#endif
-}
-
-template <uint64_t distance>
-void testMixedIds() {
-  ad_utility::MilestoneIdManager<distance> m;
-  m.getNextId();
-  for (size_t i = 0; i < 680; ++i) {
-    for (size_t j = 0; j < 123; ++j) {
-      auto id = m.getNextId();
-      ASSERT_EQ(i * distance + j + 1, id);
-    }
-    auto id = m.getNextMilestoneId();
-    ASSERT_TRUE(m.isMilestoneId(id));
-    ASSERT_EQ(id, (i + 1) * distance);
-    ASSERT_EQ(m.milestoneIdToLocal(id), i + 1);
-    ASSERT_EQ(id, m.milestoneIdFromLocal(m.milestoneIdToLocal(id)));
-  }
-}
-
-TEST(MilestoneId, MixedIds) {
-  testMixedIds<256>();
-  testMixedIds<257>();
-  testMixedIds<1024 * 1024>();
-  testMixedIds<1024 * 1024 + 53>();
-}
-
-TEST(MilestoneId, Overflow) {
-  constexpr static uint64_t distance = 1ull << 63;
-  auto m = ad_utility::MilestoneIdManager<distance>{};
-  auto id = m.getNextMilestoneId();
-  ASSERT_EQ(id, 0u);
-  id = m.getNextMilestoneId();
-  ASSERT_EQ(id, distance);
-  ASSERT_THROW(m.getNextMilestoneId(),
-               ad_utility::MilestoneIdOverflowException);
-}

From 6a571f91b67e6b3ce2e4604fb59480582d6dced5 Mon Sep 17 00:00:00 2001
From: RobinTF <83676088+RobinTF@users.noreply.github.com>
Date: Wed, 12 Feb 2025 21:09:48 +0100
Subject: [PATCH 2/6] Implement limit support for `Bind` (#1795)

Just a small change that allows `Bind` to avoid computing SPARQL expressions when a `LIMIT` or `OFFSET` is present, that would just trim them away anyway.
---
 src/engine/Bind.cpp | 4 ++++
 src/engine/Bind.h   | 1 +
 2 files changed, 5 insertions(+)

diff --git a/src/engine/Bind.cpp b/src/engine/Bind.cpp
index 95de8a4dfe..a0e7e78c9a 100644
--- a/src/engine/Bind.cpp
+++ b/src/engine/Bind.cpp
@@ -27,6 +27,9 @@ size_t Bind::getCostEstimate() {
   return _subtree->getCostEstimate() + _subtree->getSizeEstimate();
 }
 
+// We delegate the limit to the child operation, so we always support it.
+bool Bind::supportsLimit() const { return true; }
+
 float Bind::getMultiplicity(size_t col) {
   // this is the newly added column
   if (col == getResultWidth() - 1) {
@@ -93,6 +96,7 @@ IdTable Bind::cloneSubView(const IdTable& idTable,
 
 // _____________________________________________________________________________
 ProtoResult Bind::computeResult(bool requestLaziness) {
+  _subtree->setLimit(getLimit());
   LOG(DEBUG) << "Get input to BIND operation..." << std::endl;
   std::shared_ptr<const Result> subRes = _subtree->getResult(requestLaziness);
   LOG(DEBUG) << "Got input to Bind operation." << std::endl;
diff --git a/src/engine/Bind.h b/src/engine/Bind.h
index 34c515fb54..0abd5b2cec 100644
--- a/src/engine/Bind.h
+++ b/src/engine/Bind.h
@@ -30,6 +30,7 @@ class Bind : public Operation {
   [[nodiscard]] size_t getResultWidth() const override;
   std::vector<QueryExecutionTree*> getChildren() override;
   size_t getCostEstimate() override;
+  bool supportsLimit() const override;
 
  private:
   uint64_t getSizeEstimateBeforeLimit() override;

From 72973057897738fb8e5943f534791e7cbe4ebf5c Mon Sep 17 00:00:00 2001
From: RobinTF <83676088+RobinTF@users.noreply.github.com>
Date: Wed, 12 Feb 2025 21:18:32 +0100
Subject: [PATCH 3/6] Fix TurtleParser for `a` predicate (#1789)

Fixes #1763
Before this fix the Turtle parser was broken for prefixes that starts with `"a"`.
---
 src/parser/RdfParser.cpp |  7 ++-----
 src/parser/RdfParser.h   |  1 +
 test/RdfParserTest.cpp   | 37 ++++++++++++++++++++++++++++++++++---
 3 files changed, 37 insertions(+), 8 deletions(-)

diff --git a/src/parser/RdfParser.cpp b/src/parser/RdfParser.cpp
index 9cf4bffe93..c100a4b1dc 100644
--- a/src/parser/RdfParser.cpp
+++ b/src/parser/RdfParser.cpp
@@ -151,16 +151,13 @@ bool TurtleParser<T>::objectList() {
 // ______________________________________________________
 template <class T>
 bool TurtleParser<T>::verb() {
-  return predicateSpecialA() || predicate();
+  return predicate() || predicateSpecialA();
 }
 
 // ___________________________________________________________________
 template <class T>
 bool TurtleParser<T>::predicateSpecialA() {
-  tok_.skipWhitespaceAndComments();
-  if (auto [success, word] = tok_.template getNextToken<TurtleTokenId::A>();
-      success) {
-    (void)word;
+  if (parseTerminal<TurtleTokenId::A>()) {
     activePredicate_ = TripleComponent::Iri::fromIriref(
         "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>");
     return true;
diff --git a/src/parser/RdfParser.h b/src/parser/RdfParser.h
index d65c05934d..063cfc35e3 100644
--- a/src/parser/RdfParser.h
+++ b/src/parser/RdfParser.h
@@ -429,6 +429,7 @@ class TurtleParser : public RdfParserBase {
   FRIEND_TEST(RdfParserTest, booleanLiteralLongForm);
   FRIEND_TEST(RdfParserTest, collection);
   FRIEND_TEST(RdfParserTest, iriref);
+  FRIEND_TEST(RdfParserTest, specialPredicateA);
 };
 
 template <class Tokenizer_T>
diff --git a/test/RdfParserTest.cpp b/test/RdfParserTest.cpp
index 6eba30f45d..780952acfe 100644
--- a/test/RdfParserTest.cpp
+++ b/test/RdfParserTest.cpp
@@ -63,12 +63,12 @@ auto checkParseResult =
   [&]() {
     ASSERT_TRUE(optionalParser.has_value());
     auto& parser = optionalParser.value();
-    ASSERT_EQ(parser.getPosition(), expectedPosition.value_or(input.size()));
+    EXPECT_EQ(parser.getPosition(), expectedPosition.value_or(input.size()));
     if (expectedLastParseResult.has_value()) {
-      ASSERT_EQ(expectedLastParseResult, parser.getLastParseResult());
+      EXPECT_EQ(expectedLastParseResult, parser.getLastParseResult());
     }
     if (expectedTriples.has_value()) {
-      ASSERT_EQ(expectedTriples, parser.getTriples());
+      EXPECT_EQ(expectedTriples, parser.getTriples());
     }
   }();
   return std::move(optionalParser.value());
@@ -1145,3 +1145,34 @@ TEST(RdfParserTest, multifileParser) {
   };
   forAllMultifileParsers(impl);
 }
+
+// _____________________________________________________________________________
+
+TEST(RdfParserTest, specialPredicateA) {
+  auto runCommonTests = [](const auto& checker) {
+    checker(
+        "@prefix a: <http://example.org/ontology/> . a:subject a:predicate "
+        "\"object\" .",
+        {}, {},
+        std::vector<TurtleTriple>{
+            {iri("<http://example.org/ontology/subject>"),
+             iri("<http://example.org/ontology/predicate>"),
+             lit("\"object\"")}});
+    checker(
+        "@prefix a: <http://example.org/ontology/> . a:subject a \"object\" .",
+        {}, {},
+        std::vector<TurtleTriple>{
+            {iri("<http://example.org/ontology/subject>"),
+             iri("<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>"),
+             lit("\"object\"")}});
+  };
+
+  auto parseTwoStatements = []<typename Parser>(Parser& parser) {
+    return parser.statement() && parser.statement();
+  };
+
+  auto checkRe2 = checkParseResult<Re2Parser, parseTwoStatements>;
+  auto checkCTRE = checkParseResult<CtreParser, parseTwoStatements>;
+  runCommonTests(checkRe2);
+  runCommonTests(checkCTRE);
+}

From 2697035347eacdc9b32a57c578f36fad5db2e04e Mon Sep 17 00:00:00 2001
From: Julian <14220769+Qup42@users.noreply.github.com>
Date: Wed, 12 Feb 2025 21:31:24 +0100
Subject: [PATCH 4/6] Various smaller improvements for `SPARQL Update` (#1784)

- Store the `DeltaTriplesCount` as signed integer. The difference would otherwise underflow.
- Add the number of insertions and deletions by an UPDATE operation to the returned metadata. Previously only information on the change in the delta triples was given. This only allowed limited conclusion on the effect of the update as insertions and deletions can cancel out in the number of delta triples over a operation.
- Return a JSON from the `clear-delta-triples` command with the number of delta triples after the clear. This is more consistent with the other operations.
- The triples to insert/delete are sorted and removed of duplicates earlier in the triple calculation (`ExecuteUpdate` vs. `DeltaTriples`). Triples that are inserted in an operation will not be deleted before that in the same operation.
---
 src/engine/ExecuteUpdate.cpp   | 22 ++++++++++++
 src/engine/ExecuteUpdate.h     | 13 +++++++
 src/engine/Server.cpp          | 15 +++++---
 src/index/DeltaTriples.cpp     |  8 +++--
 src/index/DeltaTriples.h       | 12 ++++---
 test/DeltaTriplesCountTest.cpp |  5 ++-
 test/DeltaTriplesTest.cpp      | 30 ++++++++++------
 test/DeltaTriplesTestHelpers.h |  2 +-
 test/ExecuteUpdateTest.cpp     | 66 ++++++++++++++++++++++++++++------
 test/ServerTest.cpp            |  3 +-
 10 files changed, 138 insertions(+), 38 deletions(-)

diff --git a/src/engine/ExecuteUpdate.cpp b/src/engine/ExecuteUpdate.cpp
index 3637410d22..7e43ae1ef3 100644
--- a/src/engine/ExecuteUpdate.cpp
+++ b/src/engine/ExecuteUpdate.cpp
@@ -176,9 +176,31 @@ ExecuteUpdate::computeGraphUpdateQuads(
       cancellationHandle->throwIfCancelled();
     }
   }
+  sortAndRemoveDuplicates(toInsert);
+  sortAndRemoveDuplicates(toDelete);
+  metadata.inUpdate_ = DeltaTriplesCount{static_cast<int64_t>(toInsert.size()),
+                                         static_cast<int64_t>(toDelete.size())};
+  toDelete = setMinus(toDelete, toInsert);
   metadata.triplePreparationTime_ = timer.msecs();
 
   return {
       IdTriplesAndLocalVocab{std::move(toInsert), std::move(localVocabInsert)},
       IdTriplesAndLocalVocab{std::move(toDelete), std::move(localVocabDelete)}};
 }
+
+// _____________________________________________________________________________
+void ExecuteUpdate::sortAndRemoveDuplicates(
+    std::vector<IdTriple<>>& container) {
+  ql::ranges::sort(container);
+  container.erase(std::unique(container.begin(), container.end()),
+                  container.end());
+}
+
+// _____________________________________________________________________________
+std::vector<IdTriple<>> ExecuteUpdate::setMinus(
+    const std::vector<IdTriple<>>& a, const std::vector<IdTriple<>>& b) {
+  std::vector<IdTriple<>> reducedToDelete;
+  reducedToDelete.reserve(a.size());
+  ql::ranges::set_difference(a, b, std::back_inserter(reducedToDelete));
+  return reducedToDelete;
+}
diff --git a/src/engine/ExecuteUpdate.h b/src/engine/ExecuteUpdate.h
index 0f7e462c44..34b6b8177a 100644
--- a/src/engine/ExecuteUpdate.h
+++ b/src/engine/ExecuteUpdate.h
@@ -17,6 +17,7 @@ struct UpdateMetadata {
   Milliseconds triplePreparationTime_ = Zero;
   Milliseconds insertionTime_ = Zero;
   Milliseconds deletionTime_ = Zero;
+  std::optional<DeltaTriplesCount> inUpdate_;
 };
 
 class ExecuteUpdate {
@@ -71,4 +72,16 @@ class ExecuteUpdate {
                           const CancellationHandle& cancellationHandle,
                           UpdateMetadata& metadata);
   FRIEND_TEST(ExecuteUpdate, computeGraphUpdateQuads);
+
+  // After the operation the vector is sorted and contains no duplicate
+  // elements.
+  static void sortAndRemoveDuplicates(std::vector<IdTriple<>>& container);
+  FRIEND_TEST(ExecuteUpdate, sortAndRemoveDuplicates);
+
+  // For two sorted vectors `A` and `B` return a new vector
+  // that contains the element of `A\B`.
+  // Precondition: the inputs must be sorted.
+  static std::vector<IdTriple<>> setMinus(const std::vector<IdTriple<>>& a,
+                                          const std::vector<IdTriple<>>& b);
+  FRIEND_TEST(ExecuteUpdate, setMinus);
 };
diff --git a/src/engine/Server.cpp b/src/engine/Server.cpp
index afb15ac841..3febf6c51a 100644
--- a/src/engine/Server.cpp
+++ b/src/engine/Server.cpp
@@ -297,12 +297,15 @@ Awaitable<void> Server::process(
         [this] {
           // Use `this` explicitly to silence false-positive errors on the
           // captured `this` being unused.
-          this->index_.deltaTriplesManager().clear();
+          return this->index_.deltaTriplesManager().modify<DeltaTriplesCount>(
+              [](auto& deltaTriples) {
+                deltaTriples.clear();
+                return deltaTriples.getCounts();
+              });
         },
         handle);
-    co_await std::move(coroutine);
-    response = createOkResponse("Delta triples have been cleared", request,
-                                MediaType::textPlain);
+    auto countAfterClear = co_await std::move(coroutine);
+    response = createJsonResponse(nlohmann::json{countAfterClear}, request);
   } else if (auto cmd = checkParameter("cmd", "get-settings")) {
     logCommand(cmd, "get server settings");
     response = createJsonResponse(RuntimeParameters().toMap(), request);
@@ -821,6 +824,10 @@ json Server::createResponseMetadataForUpdate(
   response["delta-triples"]["after"] = nlohmann::json(countAfter);
   response["delta-triples"]["difference"] =
       nlohmann::json(countAfter - countBefore);
+  if (updateMetadata.inUpdate_.has_value()) {
+    response["delta-triples"]["operation"] =
+        json(updateMetadata.inUpdate_.value());
+  }
   response["time"]["planning"] =
       formatTime(runtimeInfoWholeOp.timeQueryPlanning);
   response["time"]["where"] =
diff --git a/src/index/DeltaTriples.cpp b/src/index/DeltaTriples.cpp
index e8d35fa3b3..c3ecad2bde 100644
--- a/src/index/DeltaTriples.cpp
+++ b/src/index/DeltaTriples.cpp
@@ -150,9 +150,9 @@ void DeltaTriples::modifyTriplesImpl(CancellationHandle cancellationHandle,
                                      TriplesToHandlesMap& targetMap,
                                      TriplesToHandlesMap& inverseMap) {
   rewriteLocalVocabEntriesAndBlankNodes(triples);
-  ql::ranges::sort(triples);
-  auto first = std::unique(triples.begin(), triples.end());
-  triples.erase(first, triples.end());
+  AD_EXPENSIVE_CHECK(ql::ranges::is_sorted(triples));
+  AD_EXPENSIVE_CHECK(std::unique(triples.begin(), triples.end()) ==
+                     triples.end());
   std::erase_if(triples, [&targetMap](const IdTriple<0>& triple) {
     return targetMap.contains(triple);
   });
@@ -248,6 +248,8 @@ template void DeltaTriplesManager::modify<void>(
     std::function<void(DeltaTriples&)> const&);
 template nlohmann::json DeltaTriplesManager::modify<nlohmann::json>(
     const std::function<nlohmann::json(DeltaTriples&)>&);
+template DeltaTriplesCount DeltaTriplesManager::modify<DeltaTriplesCount>(
+    const std::function<DeltaTriplesCount(DeltaTriples&)>&);
 
 // _____________________________________________________________________________
 void DeltaTriplesManager::clear() { modify<void>(&DeltaTriples::clear); }
diff --git a/src/index/DeltaTriples.h b/src/index/DeltaTriples.h
index 3a2037768c..aa1f3e67e7 100644
--- a/src/index/DeltaTriples.h
+++ b/src/index/DeltaTriples.h
@@ -40,8 +40,8 @@ class SharedLocatedTriplesSnapshot
 
 // A class for keeping track of the number of triples of the `DeltaTriples`.
 struct DeltaTriplesCount {
-  size_t triplesInserted_;
-  size_t triplesDeleted_;
+  int64_t triplesInserted_;
+  int64_t triplesDeleted_;
 
   /// Output as json. The signature of this function is mandated by the json
   /// library to allow for implicit conversion.
@@ -146,8 +146,12 @@ class DeltaTriples {
   void clear();
 
   // The number of delta triples added and subtracted.
-  size_t numInserted() const { return triplesInserted_.size(); }
-  size_t numDeleted() const { return triplesDeleted_.size(); }
+  int64_t numInserted() const {
+    return static_cast<int64_t>(triplesInserted_.size());
+  }
+  int64_t numDeleted() const {
+    return static_cast<int64_t>(triplesDeleted_.size());
+  }
   DeltaTriplesCount getCounts() const;
 
   // Insert triples.
diff --git a/test/DeltaTriplesCountTest.cpp b/test/DeltaTriplesCountTest.cpp
index 1a72f356de..b04c0b4745 100644
--- a/test/DeltaTriplesCountTest.cpp
+++ b/test/DeltaTriplesCountTest.cpp
@@ -21,7 +21,6 @@ TEST(DeltaTriplesCountTest, toJson) {
 TEST(DeltaTriplesCountTest, subtractOperator) {
   constexpr DeltaTriplesCount count1{10, 5};
   constexpr DeltaTriplesCount count2{3, 2};
-  constexpr DeltaTriplesCount expected{7, 3};
-  const DeltaTriplesCount actual = count1 - count2;
-  EXPECT_THAT(actual, testing::Eq(expected));
+  EXPECT_THAT(count1 - count2, testing::Eq(DeltaTriplesCount{7, 3}));
+  EXPECT_THAT(count2 - count1, testing::Eq(DeltaTriplesCount{-7, -3}));
 }
diff --git a/test/DeltaTriplesTest.cpp b/test/DeltaTriplesTest.cpp
index e0fe673c39..3b4564f483 100644
--- a/test/DeltaTriplesTest.cpp
+++ b/test/DeltaTriplesTest.cpp
@@ -149,7 +149,7 @@ TEST_F(DeltaTriplesTest, insertTriplesAndDeleteTriples) {
 
   EXPECT_THAT(deltaTriples, StateIs(0, 0, 0, {}, {}));
 
-  // Inserting triples.
+  // Inserting triples. The triples being inserted must be sorted.
   deltaTriples.insertTriples(
       cancellationHandle,
       makeIdTriples(vocab, localVocab, {"<A> <B> <C>", "<A> <B> <D>"}));
@@ -164,14 +164,14 @@ TEST_F(DeltaTriplesTest, insertTriplesAndDeleteTriples) {
       deltaTriples,
       StateIs(3, 0, 3, {"<A> <B> <C>", "<A> <B> <D>", "<A> <low> <a>"}, {}));
 
-  // Inserting unsorted triples works.
+  // Insert more triples.
   deltaTriples.insertTriples(
       cancellationHandle,
-      makeIdTriples(vocab, localVocab, {"<B> <D> <C>", "<B> <C> <D>"}));
+      makeIdTriples(vocab, localVocab, {"<B> <C> <D>", "<B> <D> <C>"}));
   EXPECT_THAT(deltaTriples,
               StateIs(5, 0, 5,
-                      {"<A> <B> <C>", "<A> <B> <D>", "<B> <D> <C>",
-                       "<B> <C> <D>", "<A> <low> <a>"},
+                      {"<A> <B> <C>", "<A> <B> <D>", "<B> <C> <D>",
+                       "<B> <D> <C>", "<A> <low> <a>"},
                       {}));
 
   // Inserting already inserted triples has no effect.
@@ -212,10 +212,20 @@ TEST_F(DeltaTriplesTest, insertTriplesAndDeleteTriples) {
           {"<A> <B> <C>", "<B> <C> <D>", "<A> <low> <a>", "<B> <D> <C>"},
           {"<A> <B> <D>", "<A> <B> <F>", "<A> <next> <B>", "<B> <next> <C>"}));
 
-  // Deleting unsorted triples.
+  // Unsorted triples are not allowed.
+  if constexpr (ad_utility::areExpensiveChecksEnabled) {
+    AD_EXPECT_THROW_WITH_MESSAGE(
+        deltaTriples.deleteTriples(
+            cancellationHandle,
+            makeIdTriples(vocab, localVocab,
+                          {"<C> <prev> <B>", "<B> <prev> <A>"})),
+        testing::_);
+  }
+
+  // Deleting triples.
   deltaTriples.deleteTriples(
       cancellationHandle,
-      makeIdTriples(vocab, localVocab, {"<C> <prev> <B>", "<B> <prev> <A>"}));
+      makeIdTriples(vocab, localVocab, {"<B> <prev> <A>", "<C> <prev> <B>"}));
   EXPECT_THAT(
       deltaTriples,
       StateIs(4, 6, 10,
@@ -347,7 +357,7 @@ TEST_F(DeltaTriplesTest, DeltaTriplesManager) {
            absl::StrCat("<A> <B> <E", threadIdx, ">")});
       auto triplesToDelete = makeIdTriples(
           vocab, localVocab,
-          {"<A> <C> <E>", absl::StrCat("<A> <B> <E", threadIdx, ">"),
+          {"<A> <A> <E>", absl::StrCat("<A> <B> <E", threadIdx, ">"),
            absl::StrCat("<A> <B> <F", threadIdx, ">")});
       // Insert the `triplesToInsert`.
       deltaTriplesManager.modify<void>([&](DeltaTriples& deltaTriples) {
@@ -416,10 +426,8 @@ TEST_F(DeltaTriplesTest, DeltaTriplesManager) {
   // thread-exclusive triple and inserts one thread-exclusive triple that is
   // deleted right after (This triple is stored as deleted in the `DeltaTriples`
   // because it might be contained in the original input). Additionally, there
-  // is one common triple inserted by// all the threads and one common triple
+  // is one common triple inserted by all the threads and one common triple
   // that is deleted by all the threads.
-  //
-
   auto deltaImpl = deltaTriplesManager.deltaTriples_.rlock();
   EXPECT_THAT(*deltaImpl, NumTriples(numThreads + 1, 2 * numThreads + 1,
                                      3 * numThreads + 2));
diff --git a/test/DeltaTriplesTestHelpers.h b/test/DeltaTriplesTestHelpers.h
index 17d8e994ce..8bbd39ac6b 100644
--- a/test/DeltaTriplesTestHelpers.h
+++ b/test/DeltaTriplesTestHelpers.h
@@ -41,7 +41,7 @@ inline auto NumTriplesInAllPermutations =
 // `getCounts()` of a `DeltaTriples` and `numTriples()` for all
 // `LocatedTriplesPerBlock` of the `DeltaTriples`.
 inline auto NumTriples =
-    [](size_t inserted, size_t deleted,
+    [](int64_t inserted, int64_t deleted,
        size_t inAllPermutations) -> testing::Matcher<const DeltaTriples&> {
   return testing::AllOf(
       AD_PROPERTY(DeltaTriples, numInserted, testing::Eq(inserted)),
diff --git a/test/ExecuteUpdateTest.cpp b/test/ExecuteUpdateTest.cpp
index b376660785..a1da7bcd62 100644
--- a/test/ExecuteUpdateTest.cpp
+++ b/test/ExecuteUpdateTest.cpp
@@ -52,7 +52,9 @@ TEST(ExecuteUpdate, executeUpdate) {
   auto expectExecuteUpdate =
       [&index, &expectExecuteUpdateHelper](
           const std::string& update,
-          const testing::Matcher<const DeltaTriples&>& deltaTriplesMatcher) {
+          const testing::Matcher<const DeltaTriples&>& deltaTriplesMatcher,
+          source_location sourceLocation = source_location::current()) {
+        auto l = generateLocationTrace(sourceLocation);
         DeltaTriples deltaTriples{index};
         expectExecuteUpdateHelper(update, deltaTriples);
         EXPECT_THAT(deltaTriples, deltaTriplesMatcher);
@@ -127,7 +129,9 @@ TEST(ExecuteUpdate, computeGraphUpdateQuads) {
       [&executeComputeGraphUpdateQuads](
           const std::string& update,
           const Matcher<const std::vector<::IdTriple<>>&>& toInsertMatcher,
-          const Matcher<const std::vector<::IdTriple<>>&>& toDeleteMatcher) {
+          const Matcher<const std::vector<::IdTriple<>>&>& toDeleteMatcher,
+          source_location sourceLocation = source_location::current()) {
+        auto l = generateLocationTrace(sourceLocation);
         EXPECT_THAT(executeComputeGraphUpdateQuads(update),
                     Pair(AD_FIELD(ExecuteUpdate::IdTriplesAndLocalVocab,
                                   idTriples_, toInsertMatcher),
@@ -137,7 +141,9 @@ TEST(ExecuteUpdate, computeGraphUpdateQuads) {
   auto expectComputeGraphUpdateQuadsFails =
       [&executeComputeGraphUpdateQuads](
           const std::string& update,
-          const Matcher<const std::string&>& messageMatcher) {
+          const Matcher<const std::string&>& messageMatcher,
+          source_location sourceLocation = source_location::current()) {
+        auto l = generateLocationTrace(sourceLocation);
         AD_EXPECT_THROW_WITH_MESSAGE(executeComputeGraphUpdateQuads(update),
                                      messageMatcher);
       };
@@ -151,22 +157,18 @@ TEST(ExecuteUpdate, computeGraphUpdateQuads) {
       ElementsAreArray({IdTriple(Id("<z>"), Id("<label>"), Id("\"zz\"@en"))}));
   expectComputeGraphUpdateQuads(
       "DELETE { ?s <is-a> ?o } INSERT { <s> <p> <o> } WHERE { ?s <is-a> ?o }",
-      ElementsAreArray({IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>")),
-                        IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>"))}),
+      ElementsAreArray({IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>"))}),
       ElementsAreArray({IdTriple(Id("<x>"), Id("<is-a>"), Id("<y>")),
                         IdTriple(Id("<y>"), Id("<is-a>"), Id("<x>"))}));
   expectComputeGraphUpdateQuads(
       "DELETE { <s> <p> <o> } INSERT { <s> <p> <o> } WHERE { ?s <is-a> ?o }",
-      ElementsAreArray({IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>")),
-                        IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>"))}),
-      ElementsAreArray({IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>")),
-                        IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>"))}));
+      ElementsAreArray({IdTriple(LVI("<s>"), LVI("<p>"), LVI("<o>"))}),
+      IsEmpty());
   expectComputeGraphUpdateQuads(
       "DELETE { ?s <is-a> ?o } INSERT { ?s <is-a> ?o } WHERE { ?s <is-a> ?o }",
       ElementsAreArray({IdTriple(Id("<x>"), Id("<is-a>"), Id("<y>")),
                         IdTriple(Id("<y>"), Id("<is-a>"), Id("<x>"))}),
-      ElementsAreArray({IdTriple(Id("<x>"), Id("<is-a>"), Id("<y>")),
-                        IdTriple(Id("<y>"), Id("<is-a>"), Id("<x>"))}));
+      IsEmpty());
   expectComputeGraphUpdateQuads(
       "DELETE WHERE { ?s ?p ?o }", IsEmpty(),
       UnorderedElementsAreArray(
@@ -370,3 +372,45 @@ TEST(ExecuteUpdate, computeAndAddQuadsForResultRow) {
                      ElementsAreArray({IdTriple{{V(0), V(1), V(1), V(3)}},
                                        IdTriple{{V(0), V(1), V(2), V(3)}}}));
 }
+
+TEST(ExecuteUpdate, sortAndRemoveDuplicates) {
+  auto expect = [](std::vector<IdTriple<>> input,
+                   const std::vector<IdTriple<>>& expected,
+                   source_location l = source_location::current()) {
+    auto trace = generateLocationTrace(l);
+    ExecuteUpdate::sortAndRemoveDuplicates(input);
+    EXPECT_THAT(input, testing::ElementsAreArray(expected));
+  };
+  auto IdTriple = [&](uint64_t s, uint64_t p, uint64_t o, uint64_t g = 0) {
+    return ::IdTriple({V(s), V(p), V(o), V(g)});
+  };
+  expect({}, {});
+  expect({IdTriple(1, 1, 1)}, {IdTriple(1, 1, 1)});
+  expect({IdTriple(1, 1, 1), IdTriple(2, 2, 2)},
+         {IdTriple(1, 1, 1), IdTriple(2, 2, 2)});
+  expect({IdTriple(2, 2, 2), IdTriple(1, 1, 1)},
+         {IdTriple(1, 1, 1), IdTriple(2, 2, 2)});
+  expect({IdTriple(1, 1, 1), IdTriple(1, 1, 1)}, {IdTriple(1, 1, 1)});
+  expect({IdTriple(2, 2, 2), IdTriple(3, 3, 3), IdTriple(3, 3, 3),
+          IdTriple(2, 2, 2), IdTriple(1, 1, 1)},
+         {IdTriple(1, 1, 1), IdTriple(2, 2, 2), IdTriple(3, 3, 3)});
+}
+TEST(ExecuteUpdate, setMinus) {
+  auto expect = [](std::vector<IdTriple<>> a, std::vector<IdTriple<>> b,
+                   const std::vector<IdTriple<>>& expected,
+                   source_location l = source_location::current()) {
+    auto trace = generateLocationTrace(l);
+    EXPECT_THAT(ExecuteUpdate::setMinus(a, b),
+                testing::ElementsAreArray(expected));
+  };
+  auto IdTriple = [&](uint64_t s, uint64_t p, uint64_t o, uint64_t g = 0) {
+    return ::IdTriple({V(s), V(p), V(o), V(g)});
+  };
+  expect({}, {}, {});
+  expect({IdTriple(1, 2, 3), IdTriple(4, 5, 6)}, {},
+         {IdTriple(1, 2, 3), IdTriple(4, 5, 6)});
+  expect({IdTriple(1, 2, 3), IdTriple(4, 5, 6), IdTriple(7, 8, 9)},
+         {IdTriple(4, 5, 6), IdTriple(7, 8, 9)}, {IdTriple(1, 2, 3)});
+  expect({IdTriple(1, 2, 3)},
+         {IdTriple(1, 2, 3), IdTriple(4, 5, 6), IdTriple(7, 8, 9)}, {});
+}
diff --git a/test/ServerTest.cpp b/test/ServerTest.cpp
index 9d7d69088b..e5a6e1cffc 100644
--- a/test/ServerTest.cpp
+++ b/test/ServerTest.cpp
@@ -169,7 +169,8 @@ TEST(ServerTest, createResponseMetadata) {
   json deltaTriplesJson{
       {"before", {{"inserted", 0}, {"deleted", 0}, {"total", 0}}},
       {"after", {{"inserted", 1}, {"deleted", 0}, {"total", 1}}},
-      {"difference", {{"inserted", 1}, {"deleted", 0}, {"total", 1}}}};
+      {"difference", {{"inserted", 1}, {"deleted", 0}, {"total", 1}}},
+      {"operation", {{"inserted", 1}, {"deleted", 0}, {"total", 1}}}};
   json locatedTriplesJson{
       {"SPO", {{"blocks-affected", 1}, {"blocks-total", 1}}},
       {"POS", {{"blocks-affected", 1}, {"blocks-total", 1}}},

From 702339f7f6b408788e0dd95587a5bf34ed6ce036 Mon Sep 17 00:00:00 2001
From: RobinTF <83676088+RobinTF@users.noreply.github.com>
Date: Wed, 12 Feb 2025 21:34:57 +0100
Subject: [PATCH 5/6] Correctly display wildcard port (#1796)

The log message that is printed as soon as a QLever server is started now also prints the correct port when using the wildcard port `0`. This special port causes UNIX-like systems to pick an arbitrary free port.
For fixed ports nothing changes.
---
 src/engine/Server.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/engine/Server.cpp b/src/engine/Server.cpp
index 3febf6c51a..490f3d869e 100644
--- a/src/engine/Server.cpp
+++ b/src/engine/Server.cpp
@@ -83,8 +83,6 @@ void Server::initialize(const string& indexBaseName, bool useText,
 
   LOG(INFO) << "Access token for restricted API calls is \"" << accessToken_
             << "\"" << std::endl;
-  LOG(INFO) << "The server is ready, listening for requests on port "
-            << std::to_string(port_) << " ..." << std::endl;
 }
 
 // _____________________________________________________________________________
@@ -166,6 +164,9 @@ void Server::run(const string& indexBaseName, bool useText, bool usePatterns,
   // Initialize the index
   initialize(indexBaseName, useText, usePatterns, loadAllPermutations);
 
+  LOG(INFO) << "The server is ready, listening for requests on port "
+            << std::to_string(httpServer.getPort()) << " ..." << std::endl;
+
   // Start listening for connections on the server.
   httpServer.run();
 }

From cfc49a910d4524fbef4b18ea30142d877ed8fe8c Mon Sep 17 00:00:00 2001
From: gpicciuca <dangertauros@gmail.com>
Date: Thu, 13 Feb 2025 13:28:30 +0100
Subject: [PATCH 6/6] Backport of some concepts from `util` to C++17 (#1741)

This affects many files, as the `util/TypeTraits.h` header introduces several general concepts that are used all across the QLever codebase.
---
 .clang-format                                 |   4 +
 benchmark/JoinAlgorithmBenchmark.cpp          |  36 +--
 .../BenchmarkMeasurementContainer.h           |   4 +-
 benchmark/infrastructure/BenchmarkToJson.cpp  |  12 +-
 benchmark/util/ResultTableColumnOperations.h  |   5 +-
 src/backports/concepts.h                      |  25 +-
 src/backports/cppTemplate2.h                  |  60 ++++
 src/engine/ExportQueryExecutionTrees.cpp      |   2 +-
 src/engine/Filter.cpp                         |  17 +-
 src/engine/Filter.h                           |  17 +-
 src/engine/Server.cpp                         |   4 +-
 src/engine/Server.h                           |  19 +-
 src/engine/idTable/IdTableRow.h               |   6 +-
 .../RelationalExpressions.cpp                 |   9 +-
 .../sparqlExpressions/SparqlExpressionTypes.h |  17 +-
 src/global/Pattern.h                          |  10 +-
 src/index/CompressedRelation.cpp              |  15 +-
 src/index/CompressedRelation.h                |  15 +-
 src/index/IndexBuilderTypes.h                 |   3 +-
 src/index/StringSortComparator.h              |   4 +-
 src/index/VocabularyMergerImpl.h              |   2 +-
 src/index/vocabulary/CompressionWrappers.h    |   2 +
 src/util/Algorithm.h                          |  31 +-
 src/util/AllocatorWithLimit.h                 |   5 +-
 src/util/AsioHelpers.h                        |  28 +-
 src/util/Cache.h                              |  71 ++---
 src/util/CancellationHandle.cpp               |   8 +-
 src/util/CancellationHandle.h                 |  35 ++-
 src/util/ChunkedForLoop.h                     |  47 +--
 src/util/CompressionUsingZstd/ZstdWrapper.h   |  16 +-
 src/util/Concepts.h                           |  12 +-
 src/util/ConfigManager/ConfigManager.cpp      | 125 ++++----
 src/util/ConfigManager/ConfigManager.h        | 271 ++++++++++--------
 src/util/ConfigManager/ConfigOption.h         |  34 ++-
 src/util/ConfigManager/ConfigOptionProxy.h    |  10 +-
 src/util/ConfigManager/Validator.h            |  73 ++---
 src/util/ConstexprSmallString.h               |   2 +-
 src/util/ConstexprUtils.h                     |  64 +++--
 src/util/CopyableUniquePtr.h                  |  11 +-
 src/util/DefaultValueSizeGetter.h             |  11 +-
 src/util/Exception.h                          |  18 +-
 src/util/ExceptionHandling.h                  |  37 +--
 src/util/Generator.h                          |   9 +-
 src/util/Iterators.h                          |  79 ++---
 src/util/JoinAlgorithms/FindUndefRanges.h     |  32 ++-
 src/util/LambdaHelpers.h                      |  70 ++++-
 src/util/MemorySize/MemorySize.h              | 101 ++++---
 src/util/MmapVector.h                         |  22 +-
 src/util/NBitInteger.h                        |   4 +-
 ...DestructionDontThrowDuringStackUnwinding.h |  11 +-
 src/util/ParallelMultiwayMerge.h              |  94 +++---
 src/util/Parameters.h                         |  29 +-
 src/util/ProgramOptionsHelpers.h              |   5 +-
 src/util/ProgressBar.h                        |  12 +-
 src/util/Random.h                             |   5 +-
 src/util/Serializer/SerializeArrayOrTuple.h   |  14 +-
 src/util/Serializer/SerializeOptional.h       |   4 +-
 src/util/Serializer/SerializeVector.h         |   4 +-
 src/util/Serializer/Serializer.h              | 137 +++++----
 src/util/StringUtils.h                        |   4 +-
 src/util/Synchronized.h                       |   7 +-
 src/util/ThreadSafeQueue.h                    |  13 +-
 src/util/Timer.h                              |   5 +-
 src/util/TransparentFunctors.h                |  12 +-
 src/util/TypeTraits.h                         | 104 +++++--
 src/util/UniqueCleanup.h                      |   5 +-
 src/util/ValueSizeGetters.h                   |   7 +-
 src/util/Views.h                              |  83 +++---
 src/util/antlr/ANTLRErrorHandling.h           |  12 +-
 src/util/http/HttpServer.h                    |  36 ++-
 src/util/http/HttpUtils.h                     |  61 ++--
 src/util/json.h                               |  52 ++--
 src/util/stream_generator.h                   |   4 +-
 test/CMakeLists.txt                           |  14 +-
 test/ConfigManagerTest.cpp                    |  34 ++-
 test/ConstexprUtilsTest.cpp                   |  19 +-
 test/JsonUtilTest.cpp                         |   9 +-
 test/SerializerTest.cpp                       |   9 +-
 test/SparqlAntlrParserTest.cpp                |   5 +-
 test/TypeTraitsTest.cpp                       |  19 ++
 test/ValidatorTest.cpp                        |   8 +-
 test/backports/CMakeLists.txt                 |   3 +-
 test/backports/ConceptsTest.cpp               |  41 +++
 .../BenchmarkMeasurementContainerHelpers.cpp  |   6 +-
 .../BenchmarkMeasurementContainerHelpers.h    |   6 +-
 test/util/IdTableHelpers.h                    |   3 +-
 test/util/ValidatorHelpers.cpp                |   6 +-
 test/util/ValidatorHelpers.h                  |   6 +-
 88 files changed, 1479 insertions(+), 943 deletions(-)
 create mode 100644 src/backports/cppTemplate2.h
 create mode 100644 test/backports/ConceptsTest.cpp

diff --git a/.clang-format b/.clang-format
index 9aaf52be23..bc7beb36a7 100644
--- a/.clang-format
+++ b/.clang-format
@@ -6,4 +6,8 @@ LineEnding: LF
 InsertNewlineAtEOF: true
 RequiresClausePosition: SingleLine
 IndentRequiresClause: false
+AttributeMacros: [CPP_member, CPP_auto_member, CPP_fun, CPP_auto_fun]
+# TODO<joka921> Update to Clang-format-17 and then we can have much nicer CPP_... macros.
+#Macros:
+#  - CPP_template_2(x)=template<x> requires
 ...
diff --git a/benchmark/JoinAlgorithmBenchmark.cpp b/benchmark/JoinAlgorithmBenchmark.cpp
index 553785609f..49d8059e83 100644
--- a/benchmark/JoinAlgorithmBenchmark.cpp
+++ b/benchmark/JoinAlgorithmBenchmark.cpp
@@ -770,27 +770,29 @@ class GeneralInterfaceImplementation : public BenchmarkInterface {
       };
     };
     auto generateBiggerEqualLambdaDesc =
-        [](const ad_utility::isInstantiation<
-               ad_utility::ConstConfigOptionProxy> auto& option,
-           const auto& minimumValue, bool canBeEqual) {
-          return absl::StrCat("'", option.getConfigOption().getIdentifier(),
-                              "' must be bigger than",
-                              canBeEqual ? ", or equal to," : "", " ",
-                              minimumValue, ".");
-        };
+        []<typename OptionType,
+           typename = std::enable_if_t<ad_utility::isInstantiation<
+               OptionType, ad_utility::ConstConfigOptionProxy>>>(
+            const OptionType& option, const auto& minimumValue,
+            bool canBeEqual) {
+      return absl::StrCat("'", option.getConfigOption().getIdentifier(),
+                          "' must be bigger than",
+                          canBeEqual ? ", or equal to," : "", " ", minimumValue,
+                          ".");
+    };
 
     // Object with a `operator()` for the `<=` operator.
     auto lessEqualLambda = std::less_equal<size_t>{};
     auto generateLessEqualLambdaDesc =
-        [](const ad_utility::isInstantiation<
-               ad_utility::ConstConfigOptionProxy> auto& lhs,
-           const ad_utility::isInstantiation<
-               ad_utility::ConstConfigOptionProxy> auto& rhs) {
-          return absl::StrCat("'", lhs.getConfigOption().getIdentifier(),
-                              "' must be smaller than, or equal to, "
-                              "'",
-                              rhs.getConfigOption().getIdentifier(), "'.");
-        };
+        []<typename OptionType,
+           typename = std::enable_if_t<ad_utility::isInstantiation<
+               OptionType, ad_utility::ConstConfigOptionProxy>>>(
+            const OptionType& lhs, const OptionType& rhs) {
+      return absl::StrCat("'", lhs.getConfigOption().getIdentifier(),
+                          "' must be smaller than, or equal to, "
+                          "'",
+                          rhs.getConfigOption().getIdentifier(), "'.");
+    };
 
     // Adding the validators.
 
diff --git a/benchmark/infrastructure/BenchmarkMeasurementContainer.h b/benchmark/infrastructure/BenchmarkMeasurementContainer.h
index 7700e1fd18..98988f776f 100644
--- a/benchmark/infrastructure/BenchmarkMeasurementContainer.h
+++ b/benchmark/infrastructure/BenchmarkMeasurementContainer.h
@@ -227,8 +227,8 @@ class ResultTable : public BenchmarkMetadataGetter {
 
   @param row, column Which table entry to read. Starts with `(0,0)`.
   */
-  template <ad_utility::SameAsAnyTypeIn<EntryType> T>
-  T getEntry(const size_t row, const size_t column) const {
+  CPP_template(typename T)(requires ad_utility::SameAsAnyTypeIn<T, EntryType>) T
+      getEntry(const size_t row, const size_t column) const {
     AD_CONTRACT_CHECK(row < numRows() && column < numColumns());
     static_assert(!ad_utility::isSimilar<T, std::monostate>);
 
diff --git a/benchmark/infrastructure/BenchmarkToJson.cpp b/benchmark/infrastructure/BenchmarkToJson.cpp
index b5430304bf..897f30c731 100644
--- a/benchmark/infrastructure/BenchmarkToJson.cpp
+++ b/benchmark/infrastructure/BenchmarkToJson.cpp
@@ -31,12 +31,12 @@ provided translation function for the vector entries.
 @tparam TranslationFunction Has to be a function, that takes `VectorType`
 and returns a `nlohmann:json` object.
 */
-template <typename VectorType, ad_utility::InvocableWithExactReturnType<
-                                   nlohmann::ordered_json, VectorType>
-                                   TranslationFunction>
-static nlohmann::json transformIntoJsonArray(
-    const std::vector<VectorType>& vec,
-    TranslationFunction translationFunction) {
+CPP_template(typename VectorType, typename TranslationFunction)(
+    requires ad_utility::InvocableWithExactReturnType<
+        TranslationFunction, nlohmann::ordered_json,
+        VectorType>) static nlohmann::json
+    transformIntoJsonArray(const std::vector<VectorType>& vec,
+                           TranslationFunction translationFunction) {
   /*
   Without explicit instantiation, `nlohmann::nlohmann::ordered_json` is not
   guaranteed, to always interpret a `push_back` correctly. For instance,
diff --git a/benchmark/util/ResultTableColumnOperations.h b/benchmark/util/ResultTableColumnOperations.h
index 46883c6208..3967ea77b0 100644
--- a/benchmark/util/ResultTableColumnOperations.h
+++ b/benchmark/util/ResultTableColumnOperations.h
@@ -21,8 +21,9 @@ Column number together with the type of value, that can be found inside the
 column. Note, that **all** entries in the column must have the same type,
 because of `ResultTable::getEntry`.
 */
-template <ad_utility::SameAsAnyTypeIn<ResultTable::EntryType> Type>
-struct ColumnNumWithType {
+CPP_template(typename Type)(
+    requires ad_utility::SameAsAnyTypeIn<
+        Type, ResultTable::EntryType>) struct ColumnNumWithType {
   using ColumnType = Type;
   const size_t columnNum_;
 };
diff --git a/src/backports/concepts.h b/src/backports/concepts.h
index 3049c55c5c..17a2f3e5c4 100644
--- a/src/backports/concepts.h
+++ b/src/backports/concepts.h
@@ -5,6 +5,8 @@
 #pragma once
 
 #include <concepts/concepts.hpp>
+
+#include "backports/cppTemplate2.h"
 #ifndef QLEVER_CPP_17
 #include <concepts>
 #endif
@@ -32,18 +34,34 @@
 // NOTE: The macros are variadic to allow for commas in the argument, like in
 // the second example above.
 
+// Additionally define the macros `CPP_template_2` and `CPP_and_2` that can
+// be used to constrain member functions of classes where the outer class
+// has already been constrained with `CPP_template`. For a detailed example, see
+// the `test/backports/ConceptsTest.cpp` file.
+
 #ifdef QLEVER_CPP_17
 #define QL_CONCEPT_OR_NOTHING(...)
 #define QL_CONCEPT_OR_TYPENAME(...) typename
+#define CPP_template_2 CPP_template_2_SFINAE
+#define CPP_and_2 CPP_and_2_sfinae
+#define CPP_and_def CPP_and_sfinae_def
+#define CPP_and_2_def CPP_and_2_def_sfinae
+#define CPP_variadic_template CPP_template_NO_DEFAULT_SFINAE
+#define CPP_member_def CPP_member_def_sfinae
 #else
 #define QL_CONCEPT_OR_NOTHING(...) __VA_ARGS__
 #define QL_CONCEPT_OR_TYPENAME(...) __VA_ARGS__
+#define CPP_template_2 CPP_template
+#define CPP_and_2 CPP_and
+#define CPP_and_def CPP_and
+#define CPP_and_2_def CPP_and
+#define CPP_variadic_template CPP_template
+#define CPP_member_def CPP_member
 #endif
 
 // The namespace `ql::concepts` includes concepts that are contained in the
 // C++20 standard as well as in `range-v3`.
-namespace ql {
-namespace concepts {
+namespace ql::concepts {
 
 #ifdef QLEVER_CPP_17
 using namespace ::concepts;
@@ -51,5 +69,4 @@ using namespace ::concepts;
 using namespace std;
 #endif
 
-}  // namespace concepts
-}  // namespace ql
+}  // namespace ql::concepts
diff --git a/src/backports/cppTemplate2.h b/src/backports/cppTemplate2.h
new file mode 100644
index 0000000000..a5c89b2c16
--- /dev/null
+++ b/src/backports/cppTemplate2.h
@@ -0,0 +1,60 @@
+// Copyright 2024, University of Freiburg
+// Chair of Algorithms and Data Structures
+// Author: Johannes Kalmbach <kalmbach@cs.uni-freiburg.de>
+
+#pragma once
+#include <concepts/concepts.hpp>
+
+// The internal reimplementation of a `CPP_variadic_template` macro
+// that can be used for variadic template functions.
+#define CPP_TEMPLATE_NO_DEFAULT_SFINAE_AUX_0(...)                         \
+  , std::enable_if_t<CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__), \
+                     int> = 0 > CPP_PP_IGNORE_CXX2A_COMPAT_END
+
+#define CPP_TEMPLATE_NO_DEFAULT_SFINAE_AUX_3_requires
+
+#define CPP_TEMPLATE_NO_DEFAULT_SFINAE_AUX_WHICH_(FIRST, ...) \
+  CPP_PP_EVAL(CPP_PP_CHECK,                                   \
+              CPP_PP_CAT(CPP_TEMPLATE_SFINAE_PROBE_CONCEPT_, FIRST))
+
+#define CPP_TEMPLATE_NO_DEFAULT_SFINAE_AUX_(...)                       \
+  CPP_PP_CAT(CPP_TEMPLATE_NO_DEFAULT_SFINAE_AUX_,                      \
+             CPP_TEMPLATE_NO_DEFAULT_SFINAE_AUX_WHICH_(__VA_ARGS__, )) \
+  (__VA_ARGS__)
+
+#define CPP_template_NO_DEFAULT_SFINAE(...) \
+  CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN          \
+  template <__VA_ARGS__ CPP_TEMPLATE_NO_DEFAULT_SFINAE_AUX_
+
+// The internal reimplementation of a `CPP_template_2` and `CPP_and_2` macro
+// that can be used for class members when the outer class has already been
+// constrained using `CPP_template`.
+#define CPP_TEMPLATE_2_SFINAE_AUX_0(...)                                \
+  , bool CPP_true_2 = true,                                             \
+         std::enable_if_t <                                             \
+                 CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__) && \
+             CPP_BOOL(CPP_true_2),                                      \
+         int > = 0 > CPP_PP_IGNORE_CXX2A_COMPAT_END
+
+#define CPP_TEMPLATE_2_SFINAE_AUX_3_requires
+
+#define CPP_TEMPLATE_2_SFINAE_AUX_WHICH_(FIRST, ...) \
+  CPP_PP_EVAL(CPP_PP_CHECK,                          \
+              CPP_PP_CAT(CPP_TEMPLATE_SFINAE_PROBE_CONCEPT_, FIRST))
+
+#define CPP_TEMPLATE_2_SFINAE_AUX_(...)                       \
+  CPP_PP_CAT(CPP_TEMPLATE_2_SFINAE_AUX_,                      \
+             CPP_TEMPLATE_2_SFINAE_AUX_WHICH_(__VA_ARGS__, )) \
+  (__VA_ARGS__)
+
+#define CPP_template_2_SFINAE(...) \
+  CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN \
+  template <__VA_ARGS__ CPP_TEMPLATE_2_SFINAE_AUX_
+
+/// INTERNAL ONLY
+#define CPP_and_def_sfinae &&CPP_BOOL(CPP_true), int >, std::enable_if_t <
+#define CPP_and_2_sfinae &&CPP_BOOL(CPP_true_2), int > = 0, std::enable_if_t <
+#define CPP_and_2_def_sfinae &&CPP_BOOL(CPP_true_2), int >, std::enable_if_t <
+
+#define CPP_member_def_sfinae \
+  template <bool (&CPP_true_fn)(::concepts::detail::xNil)>
diff --git a/src/engine/ExportQueryExecutionTrees.cpp b/src/engine/ExportQueryExecutionTrees.cpp
index 90813a3a2e..f50bca9f61 100644
--- a/src/engine/ExportQueryExecutionTrees.cpp
+++ b/src/engine/ExportQueryExecutionTrees.cpp
@@ -901,7 +901,7 @@ cppcoro::generator<std::string> ExportQueryExecutionTrees::computeResult(
 
   auto inner =
       ad_utility::ConstexprSwitch<csv, tsv, octetStream, turtle, sparqlXml,
-                                  sparqlJson, qleverJson>(compute, mediaType);
+                                  sparqlJson, qleverJson>{}(compute, mediaType);
   return convertStreamGeneratorForChunkedTransfer(std::move(inner));
 }
 
diff --git a/src/engine/Filter.cpp b/src/engine/Filter.cpp
index 7f20b58108..4ac9bc5aea 100644
--- a/src/engine/Filter.cpp
+++ b/src/engine/Filter.cpp
@@ -104,10 +104,10 @@ ProtoResult Filter::computeResult(bool requestLaziness) {
 }
 
 // _____________________________________________________________________________
-template <ad_utility::SimilarTo<IdTable> Table>
-IdTable Filter::filterIdTable(std::vector<ColumnIndex> sortedBy,
-                              Table&& idTable,
-                              const LocalVocab& localVocab) const {
+CPP_template_def(typename Table)(requires ad_utility::SimilarTo<Table, IdTable>)
+    IdTable Filter::filterIdTable(std::vector<ColumnIndex> sortedBy,
+                                  Table&& idTable,
+                                  const LocalVocab& localVocab) const {
   size_t width = idTable.numColumns();
   IdTable result{width, getExecutionContext()->getAllocator()};
 
@@ -120,10 +120,11 @@ IdTable Filter::filterIdTable(std::vector<ColumnIndex> sortedBy,
 }
 
 // _____________________________________________________________________________
-template <int WIDTH, ad_utility::SimilarTo<IdTable> Table>
-void Filter::computeFilterImpl(IdTable& dynamicResultTable, Table&& inputTable,
-                               const LocalVocab& localVocab,
-                               std::vector<ColumnIndex> sortedBy) const {
+CPP_template_def(int WIDTH, typename Table)(
+    requires ad_utility::SimilarTo<Table, IdTable>) void Filter::
+    computeFilterImpl(IdTable& dynamicResultTable, Table&& inputTable,
+                      const LocalVocab& localVocab,
+                      std::vector<ColumnIndex> sortedBy) const {
   AD_CONTRACT_CHECK(inputTable.numColumns() == WIDTH || WIDTH == 0);
   IdTableStatic<WIDTH> resultTable =
       std::move(dynamicResultTable).toStatic<static_cast<size_t>(WIDTH)>();
diff --git a/src/engine/Filter.h b/src/engine/Filter.h
index 2ac01e1845..35700c4cb0 100644
--- a/src/engine/Filter.h
+++ b/src/engine/Filter.h
@@ -70,13 +70,16 @@ class Filter : public Operation {
   ProtoResult computeResult(bool requestLaziness) override;
 
   // Perform the actual filter operation of the data provided.
-  template <int WIDTH, ad_utility::SimilarTo<IdTable> Table>
-  void computeFilterImpl(IdTable& dynamicResultTable, Table&& input,
-                         const LocalVocab& localVocab,
-                         std::vector<ColumnIndex> sortedBy) const;
+  CPP_template(int WIDTH, typename Table)(
+      requires ad_utility::SimilarTo<
+          Table, IdTable>) void computeFilterImpl(IdTable& dynamicResultTable,
+                                                  Table&& input,
+                                                  const LocalVocab& localVocab,
+                                                  std::vector<ColumnIndex>
+                                                      sortedBy) const;
 
   // Run `computeFilterImpl` on the provided IdTable
-  template <ad_utility::SimilarTo<IdTable> Table>
-  IdTable filterIdTable(std::vector<ColumnIndex> sortedBy, Table&& idTable,
-                        const LocalVocab& localVocab) const;
+  CPP_template(typename Table)(requires ad_utility::SimilarTo<Table, IdTable>)
+      IdTable filterIdTable(std::vector<ColumnIndex> sortedBy, Table&& idTable,
+                            const LocalVocab& localVocab) const;
 };
diff --git a/src/engine/Server.cpp b/src/engine/Server.cpp
index 490f3d869e..6fcb72add8 100644
--- a/src/engine/Server.cpp
+++ b/src/engine/Server.cpp
@@ -472,8 +472,8 @@ auto Server::cancelAfterDeadline(
 // _____________________________________________________________________________
 auto Server::setupCancellationHandle(
     const ad_utility::websocket::QueryId& queryId, TimeLimit timeLimit)
-    -> ad_utility::isInstantiation<
-        CancellationHandleAndTimeoutTimerCancel> auto {
+    -> QL_CONCEPT_OR_NOTHING(ad_utility::isInstantiation<
+                             CancellationHandleAndTimeoutTimerCancel>) auto {
   auto cancellationHandle = queryRegistry_.getCancellationHandle(queryId);
   AD_CORRECTNESS_CHECK(cancellationHandle);
   cancellationHandle->startWatchDog();
diff --git a/src/engine/Server.h b/src/engine/Server.h
index 9383d50c0d..24e969279a 100644
--- a/src/engine/Server.h
+++ b/src/engine/Server.h
@@ -97,8 +97,10 @@ class Server {
 
   using SharedCancellationHandle = ad_utility::SharedCancellationHandle;
 
-  template <ad_utility::isInstantiation<absl::Cleanup> CancelTimeout>
-  struct CancellationHandleAndTimeoutTimerCancel {
+  CPP_template(typename CancelTimeout)(
+      requires ad_utility::isInstantiation<
+          CancelTimeout,
+          absl::Cleanup>) struct CancellationHandleAndTimeoutTimerCancel {
     SharedCancellationHandle handle_;
     /// Object of type `absl::Cleanup` that when destroyed cancels the timer
     /// that would otherwise invoke the cancellation of the `handle_` via the
@@ -109,10 +111,11 @@ class Server {
   // Clang doesn't seem to be able to automatically deduce the type correctly.
   // and GCC 11 thinks deduction guides are not allowed within classes.
 #ifdef __clang__
-  template <ad_utility::isInstantiation<absl::Cleanup> CancelTimeout>
-  CancellationHandleAndTimeoutTimerCancel(SharedCancellationHandle,
-                                          CancelTimeout)
-      -> CancellationHandleAndTimeoutTimerCancel<CancelTimeout>;
+  CPP_template(typename CancelTimeout)(
+      requires ad_utility::isInstantiation<CancelTimeout, absl::Cleanup>)
+      CancellationHandleAndTimeoutTimerCancel(SharedCancellationHandle,
+                                              CancelTimeout)
+          -> CancellationHandleAndTimeoutTimerCancel<CancelTimeout>;
 #endif
 
   /// Handle a single HTTP request. Check whether a file request or a query was
@@ -241,8 +244,8 @@ class Server {
   /// member can be invoked to cancel the imminent cancellation via timeout.
   auto setupCancellationHandle(const ad_utility::websocket::QueryId& queryId,
                                TimeLimit timeLimit)
-      -> ad_utility::isInstantiation<
-          CancellationHandleAndTimeoutTimerCancel> auto;
+      -> QL_CONCEPT_OR_NOTHING(ad_utility::isInstantiation<
+                               CancellationHandleAndTimeoutTimerCancel>) auto;
 
   /// Check if the access token is valid. Return true if the access token
   /// exists and is valid. Return false if there's no access token passed.
diff --git a/src/engine/idTable/IdTableRow.h b/src/engine/idTable/IdTableRow.h
index cba93df96e..bf546f7cdb 100644
--- a/src/engine/idTable/IdTableRow.h
+++ b/src/engine/idTable/IdTableRow.h
@@ -385,8 +385,10 @@ class RowReference
   // The `cbegin` and `cend` functions are implicitly inherited from `Base`.
 
   // __________________________________________________________________________
-  template <ad_utility::SimilarTo<RowReference> R>
-  friend void swap(R&& a, R&& b) requires(!isConst) {
+  CPP_template(typename R)(
+      requires ad_utility::SimilarTo<RowReference, R>) friend void swap(R&& a,
+                                                                        R&& b)
+      requires(!isConst) {
     return Base::swapImpl(AD_FWD(a), AD_FWD(b));
   }
 
diff --git a/src/engine/sparqlExpressions/RelationalExpressions.cpp b/src/engine/sparqlExpressions/RelationalExpressions.cpp
index a23ce3da95..96c8a106d9 100644
--- a/src/engine/sparqlExpressions/RelationalExpressions.cpp
+++ b/src/engine/sparqlExpressions/RelationalExpressions.cpp
@@ -58,8 +58,13 @@ requires isVectorResult<S> auto idGenerator(const S& values, size_t targetSize,
 
 // For the `Variable` and `SetOfIntervals` class, the generator from the
 // `sparqlExpressions` module already yields the `ValueIds`.
-template <ad_utility::SimilarToAny<Variable, ad_utility::SetOfIntervals> S>
-auto idGenerator(S input, size_t targetSize, const EvaluationContext* context) {
+CPP_template(typename S)(
+    requires ad_utility::SimilarToAny<
+        S, Variable,
+        ad_utility::SetOfIntervals>) auto idGenerator(S input,
+                                                      size_t targetSize,
+                                                      const EvaluationContext*
+                                                          context) {
   return sparqlExpression::detail::makeGenerator(std::move(input), targetSize,
                                                  context);
 }
diff --git a/src/engine/sparqlExpressions/SparqlExpressionTypes.h b/src/engine/sparqlExpressions/SparqlExpressionTypes.h
index b54277f2c9..5f3a16a086 100644
--- a/src/engine/sparqlExpressions/SparqlExpressionTypes.h
+++ b/src/engine/sparqlExpressions/SparqlExpressionTypes.h
@@ -115,8 +115,10 @@ concept SingleExpressionResult =
     ad_utility::SimilarToAnyTypeIn<T, ExpressionResult>;
 
 // Copy an expression result.
-inline ExpressionResult copyExpressionResult(
-    ad_utility::SimilarTo<ExpressionResult> auto&& result) {
+CPP_template(typename ResultT)(
+    requires ad_utility::SimilarTo<ResultT,
+                                   ExpressionResult>) inline ExpressionResult
+    copyExpressionResult(ResultT&& result) {
   auto copyIfCopyable =
       []<SingleExpressionResult R>(const R& x) -> ExpressionResult {
     if constexpr (requires { R{AD_FWD(x)}; }) {
@@ -332,11 +334,12 @@ std::optional<ExpressionResult> evaluateOnSpecializedFunctionsIfPossible(
 // for multiple `ValueGetters` because there can be multiple `ValueGetters` as
 // well as zero or more `SpezializedFunctions`, but there can only be a single
 // parameter pack in C++.
-template <
-    size_t NumOperands,
-    ad_utility::isInstantiation<FunctionAndValueGetters>
-        FunctionAndValueGettersT,
-    ad_utility::isInstantiation<SpecializedFunction>... SpecializedFunctions>
+template <size_t NumOperands,
+          QL_CONCEPT_OR_TYPENAME(
+              ad_utility::isInstantiation<FunctionAndValueGetters>)
+              FunctionAndValueGettersT,
+          QL_CONCEPT_OR_TYPENAME(ad_utility::isInstantiation<
+                                 SpecializedFunction>)... SpecializedFunctions>
 struct Operation {
  private:
   using OriginalValueGetters = typename FunctionAndValueGettersT::ValueGetters;
diff --git a/src/global/Pattern.h b/src/global/Pattern.h
index 1005add22d..b69540e7c6 100644
--- a/src/global/Pattern.h
+++ b/src/global/Pattern.h
@@ -12,6 +12,7 @@
 #include <string>
 #include <vector>
 
+#include "backports/concepts.h"
 #include "global/Id.h"
 #include "util/ExceptionHandling.h"
 #include "util/File.h"
@@ -101,11 +102,16 @@ class CompactVectorOfStrings {
   /**
    * @brief Fills this CompactVectorOfStrings with input.
    * @param The input from which to build the vector.
+   * Note: In C++20 mode we use a `requires clause`, in C++17 mode we use a
+   * static assert. Both work, as there is only one overload of `build`.
    */
   template <typename T>
-  requires requires(T t) {
+  QL_CONCEPT_OR_NOTHING(requires requires(T t) {
     { *(t.begin()->begin()) } -> ad_utility::SimilarTo<data_type>;
-  } void build(const T& input) {
+  })
+  void build(const T& input) {
+    static_assert(
+        ad_utility::SimilarTo<decltype(*(input.begin()->begin())), data_type>);
     // Also make room for the end offset of the last element.
     _offsets.reserve(input.size() + 1);
     size_t dataSize = 0;
diff --git a/src/index/CompressedRelation.cpp b/src/index/CompressedRelation.cpp
index 63c51bd464..db84e58661 100644
--- a/src/index/CompressedRelation.cpp
+++ b/src/index/CompressedRelation.cpp
@@ -752,13 +752,14 @@ size_t CompressedRelationReader::getResultSizeOfScan(
 }
 
 // ____________________________________________________________________________
-IdTable CompressedRelationReader::getDistinctColIdsAndCountsImpl(
-    ad_utility::InvocableWithConvertibleReturnType<
-        Id, const CompressedBlockMetadata::PermutedTriple&> auto idGetter,
-    const ScanSpecification& scanSpec,
-    const std::vector<CompressedBlockMetadata>& allBlocksMetadata,
-    const CancellationHandle& cancellationHandle,
-    const LocatedTriplesPerBlock& locatedTriplesPerBlock) const {
+CPP_template_def(typename IdGetter)(
+    requires ad_utility::InvocableWithConvertibleReturnType<
+        IdGetter, Id, const CompressedBlockMetadata::PermutedTriple&>) IdTable
+    CompressedRelationReader::getDistinctColIdsAndCountsImpl(
+        IdGetter idGetter, const ScanSpecification& scanSpec,
+        const std::vector<CompressedBlockMetadata>& allBlocksMetadata,
+        const CancellationHandle& cancellationHandle,
+        const LocatedTriplesPerBlock& locatedTriplesPerBlock) const {
   // The result has two columns: one for the distinct `Id`s and one for their
   // counts.
   IdTableStatic<2> table(allocator_);
diff --git a/src/index/CompressedRelation.h b/src/index/CompressedRelation.h
index 96fefef2be..1ee4d2967d 100644
--- a/src/index/CompressedRelation.h
+++ b/src/index/CompressedRelation.h
@@ -746,13 +746,14 @@ class CompressedRelationReader {
 
   // The common implementation for `getDistinctCol0IdsAndCounts` and
   // `getCol1IdsAndCounts`.
-  IdTable getDistinctColIdsAndCountsImpl(
-      ad_utility::InvocableWithConvertibleReturnType<
-          Id, const CompressedBlockMetadata::PermutedTriple&> auto idGetter,
-      const ScanSpecification& scanSpec,
-      const std::vector<CompressedBlockMetadata>& allBlocksMetadata,
-      const CancellationHandle& cancellationHandle,
-      const LocatedTriplesPerBlock& locatedTriplesPerBlock) const;
+  CPP_template(typename IdGetter)(
+      requires ad_utility::InvocableWithConvertibleReturnType<
+          IdGetter, Id, const CompressedBlockMetadata::PermutedTriple&>) IdTable
+      getDistinctColIdsAndCountsImpl(
+          IdGetter idGetter, const ScanSpecification& scanSpec,
+          const std::vector<CompressedBlockMetadata>& allBlocksMetadata,
+          const CancellationHandle& cancellationHandle,
+          const LocatedTriplesPerBlock& locatedTriplesPerBlock) const;
 };
 
 // TODO<joka921>
diff --git a/src/index/IndexBuilderTypes.h b/src/index/IndexBuilderTypes.h
index 85f3f5d195..715a9e6d5a 100644
--- a/src/index/IndexBuilderTypes.h
+++ b/src/index/IndexBuilderTypes.h
@@ -262,7 +262,8 @@ auto getIdMapLambdas(
    * - All Ids are assigned according to itemArray[idx]
    */
   const auto itemMapLamdaCreator = [&itemArray, indexPtr](const size_t idx) {
-    return [&map = *itemArray[idx], indexPtr](ad_utility::Rvalue auto&& tr) {
+    return [&map = *itemArray[idx],
+            indexPtr](QL_CONCEPT_OR_NOTHING(ad_utility::Rvalue) auto&& tr) {
       auto lt = indexPtr->tripleToInternalRepresentation(AD_FWD(tr));
       OptionalIds res;
       // get Ids for the actual triple and store them in the result.
diff --git a/src/index/StringSortComparator.h b/src/index/StringSortComparator.h
index 651b857e6b..b5cf70c6d4 100644
--- a/src/index/StringSortComparator.h
+++ b/src/index/StringSortComparator.h
@@ -52,8 +52,8 @@ class LocaleManager {
   using U8String = std::basic_string<uint8_t>;
   using U8StringView = std::basic_string_view<uint8_t>;
 
-  template <ad_utility::SimilarToAny<U8String, U8StringView> T>
-  class SortKeyImpl {
+  CPP_template(typename T)(requires ad_utility::SimilarToAny<
+                           T, U8String, U8StringView>) class SortKeyImpl {
    public:
     SortKeyImpl() = default;
     explicit SortKeyImpl(U8StringView sortKey) : sortKey_(sortKey) {}
diff --git a/src/index/VocabularyMergerImpl.h b/src/index/VocabularyMergerImpl.h
index 1abd7ac783..6c83555c7f 100644
--- a/src/index/VocabularyMergerImpl.h
+++ b/src/index/VocabularyMergerImpl.h
@@ -95,7 +95,7 @@ auto VocabularyMerger::mergeVocabulary(const std::string& basename,
   auto mergedWords =
       ad_utility::parallelMultiwayMerge<QueueWord, true,
                                         decltype(sizeOfQueueWord)>(
-          0.8 * memoryToUse, generators, lessThanForQueue);
+          0.8 * memoryToUse, std::move(generators), lessThanForQueue);
   ad_utility::ProgressBar progressBar{metaData_.numWordsTotal(),
                                       "Words merged: "};
   for (QueueWord& currentWord : ql::views::join(mergedWords)) {
diff --git a/src/index/vocabulary/CompressionWrappers.h b/src/index/vocabulary/CompressionWrappers.h
index c299aa6119..a88f8bfbd3 100644
--- a/src/index/vocabulary/CompressionWrappers.h
+++ b/src/index/vocabulary/CompressionWrappers.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "backports/algorithm.h"
+#include "backports/concepts.h"
 #include "index/PrefixHeuristic.h"
 #include "index/vocabulary/PrefixCompressor.h"
 #include "util/FsstCompressor.h"
@@ -25,6 +26,7 @@ CPP_requires(
                                            std::vector<std::string_view>,
                                            std::vector<std::string>>,
                   ad_utility::SimilarTo<decltype(std::get<2>(t)), Decoder>));
+
 template <typename T, typename Decoder>
 CPP_concept BulkResultForDecoder =
     CPP_requires_ref(BulkResultForDecoder_, T, Decoder);
diff --git a/src/util/Algorithm.h b/src/util/Algorithm.h
index 50e23f8244..105c33ed7b 100644
--- a/src/util/Algorithm.h
+++ b/src/util/Algorithm.h
@@ -58,8 +58,10 @@ bool contains_if(const Container& container, const Predicate& predicate) {
  * @param destination Vector& to which to append
  * @param source Vector&& to append
  */
-template <typename T, ad_utility::SimilarTo<std::vector<T>> U>
-void appendVector(std::vector<T>& destination, U&& source) {
+CPP_template(typename T, typename U)(
+    requires ad_utility::SimilarTo<
+        std::vector<T>, U>) void appendVector(std::vector<T>& destination,
+                                              U&& source) {
   destination.insert(destination.end(),
                      ad_utility::makeForwardingIterator<U>(source.begin()),
                      ad_utility::makeForwardingIterator<U>(source.end()));
@@ -148,10 +150,11 @@ CPP_template(typename Range)(requires ql::ranges::forward_range<
 
 // Return a new `std::input` that is obtained by applying the `function` to each
 // of the elements of the `input`.
-template <typename Array, typename Function>
-requires(ad_utility::isArray<std::decay_t<Array>> &&
-         std::invocable<Function, typename Array::value_type>)
-auto transformArray(Array&& input, Function function) {
+CPP_template(typename Array, typename Function)(
+    requires ad_utility::isArray<std::decay_t<Array>> CPP_and std::invocable<
+        Function,
+        typename Array::value_type>) auto transformArray(Array&& input,
+                                                         Function function) {
   return std::apply(
       [&function](auto&&... vals) {
         return std::array{std::invoke(function, AD_FWD(vals))...};
@@ -163,10 +166,10 @@ auto transformArray(Array&& input, Function function) {
 // but an iterator (first argument) and a value (second argument). The
 // implementation is copied from libstdc++ which has this function as an
 // internal detail, but doesn't expose it to the outside.
-template <std::forward_iterator ForwardIterator, typename Tp, typename Compare>
-constexpr ForwardIterator lower_bound_iterator(ForwardIterator first,
-                                               ForwardIterator last,
-                                               const Tp& val, Compare comp) {
+CPP_template(typename ForwardIterator, typename Tp, typename Compare)(
+    requires std::forward_iterator<ForwardIterator>) constexpr ForwardIterator
+    lower_bound_iterator(ForwardIterator first, ForwardIterator last,
+                         const Tp& val, Compare comp) {
   using DistanceType = std::iterator_traits<ForwardIterator>::difference_type;
 
   DistanceType len = std::distance(first, last);
@@ -189,10 +192,10 @@ constexpr ForwardIterator lower_bound_iterator(ForwardIterator first,
 // but a value (first argument) and an iterator (second argument). The
 // implementation is copied from libstdc++ which has this function as an
 // internal detail, but doesn't expose it to the outside.
-template <std::forward_iterator ForwardIterator, typename Tp, typename Compare>
-constexpr ForwardIterator upper_bound_iterator(ForwardIterator first,
-                                               ForwardIterator last,
-                                               const Tp& val, Compare comp) {
+CPP_template(typename ForwardIterator, typename Tp, typename Compare)(
+    requires std::forward_iterator<ForwardIterator>) constexpr ForwardIterator
+    upper_bound_iterator(ForwardIterator first, ForwardIterator last,
+                         const Tp& val, Compare comp) {
   using DistanceType = std::iterator_traits<ForwardIterator>::difference_type;
 
   DistanceType len = std::distance(first, last);
diff --git a/src/util/AllocatorWithLimit.h b/src/util/AllocatorWithLimit.h
index 400e30d409..8aa4e72f92 100644
--- a/src/util/AllocatorWithLimit.h
+++ b/src/util/AllocatorWithLimit.h
@@ -173,9 +173,8 @@ class AllocatorWithLimit {
   }
   AllocatorWithLimit() = delete;
 
-  template <typename U>
-  requires(!std::same_as<U, T>)
-  AllocatorWithLimit(const AllocatorWithLimit<U>& other)
+  CPP_template(typename U)(requires(!std::same_as<U, T>))
+      AllocatorWithLimit(const AllocatorWithLimit<U>& other)
       : memoryLeft_{other.getMemoryLeft()},
         clearOnAllocation_(other.clearOnAllocation()){};
 
diff --git a/src/util/AsioHelpers.h b/src/util/AsioHelpers.h
index 6ae990a44d..31456c823e 100644
--- a/src/util/AsioHelpers.h
+++ b/src/util/AsioHelpers.h
@@ -26,8 +26,8 @@ namespace detail {
 // function is called directly, but the invocation of the handler is posted to
 // the associated executor of the `handler`, or to the `executor` if no such
 // associated executor exists.
-template <typename Executor, std::invocable Function, typename Handler>
-struct CallFunctionAndPassToHandler {
+CPP_template(typename Executor, typename Function, typename Handler)(
+    requires std::invocable<Function>) struct CallFunctionAndPassToHandler {
   Executor executor_;
   Function function_;
   Handler handler_;
@@ -71,11 +71,12 @@ struct CallFunctionAndPassToHandler {
 };
 // Explicit deduction guides, we need objects and not references as the template
 // parameters.
-template <typename Executor, typename Function, typename Handler>
-requires std::invocable<std::decay_t<Function>>
-CallFunctionAndPassToHandler(Executor&&, Function&&, Handler&&)
-    -> CallFunctionAndPassToHandler<
-        std::decay_t<Executor>, std::decay_t<Function>, std::decay_t<Handler>>;
+CPP_template(typename Executor, typename Function,
+             typename Handler)(requires std::invocable<std::decay_t<Function>>)
+    CallFunctionAndPassToHandler(Executor&&, Function&&, Handler&&)
+        -> CallFunctionAndPassToHandler<std::decay_t<Executor>,
+                                        std::decay_t<Function>,
+                                        std::decay_t<Handler>>;
 }  // namespace detail
 
 // Run the `function` on the `executor` (e.g. a strand for synchronization or
@@ -85,11 +86,14 @@ CallFunctionAndPassToHandler(Executor&&, Function&&, Handler&&)
 // Note: If no executor is associated with the `completionToken`, then the
 // handler will also be run on the `executor` that is passed to this function as
 // there is no other way of running it.
-template <typename Executor, typename CompletionToken, std::invocable Function>
-requires std::is_default_constructible_v<std::invoke_result_t<Function>> ||
-         std::is_void_v<std::invoke_result_t<Function>>
-auto runFunctionOnExecutor(Executor executor, Function function,
-                           CompletionToken& completionToken) {
+CPP_template(typename Executor, typename CompletionToken,
+             typename Function)(requires std::invocable<Function> CPP_and(
+    std::is_default_constructible_v<std::invoke_result_t<Function>> ||
+    std::is_void_v<std::invoke_result_t<
+        Function>>)) auto runFunctionOnExecutor(Executor executor,
+                                                Function function,
+                                                CompletionToken&
+                                                    completionToken) {
   using Value = std::invoke_result_t<Function>;
   static constexpr bool isVoid = std::is_void_v<Value>;
 
diff --git a/src/util/Cache.h b/src/util/Cache.h
index 23750eea16..e4da8e8dda 100644
--- a/src/util/Cache.h
+++ b/src/util/Cache.h
@@ -53,12 +53,12 @@ static constexpr auto size_t_max = std::numeric_limits<size_t>::max();
  @tparam ValueSizeGetter function Value -> MemorySize to determine the actual
  size of a value for statistics
  */
-template <template <typename Sc, typename Val, typename Comp>
-          class PriorityQueue,
-          class Key, class Value, typename Score, typename ScoreComparator,
-          typename AccessUpdater, typename ScoreCalculator,
-          ValueSizeGetter<Value> ValueSizeGetter>
-class FlexibleCache {
+CPP_template(template <typename Sc, typename Val, typename Comp>
+             class PriorityQueue,
+             class Key, class Value, typename Score, typename ScoreComparator,
+             typename AccessUpdater, typename ScoreCalculator,
+             typename ValueSizeGetterT)(
+    requires ValueSizeGetter<ValueSizeGetterT, Value>) class FlexibleCache {
  public:
   // For easier interaction with the STL, which often uses key_type and
   // value_type .
@@ -105,7 +105,7 @@ class FlexibleCache {
                          ScoreComparator scoreComparator,
                          AccessUpdater accessUpdater,
                          ScoreCalculator scoreCalculator,
-                         ValueSizeGetter valueSizeGetter = ValueSizeGetter())
+                         ValueSizeGetterT valueSizeGetter = ValueSizeGetterT())
       : _maxNumEntries(maxNumEntries),
         _maxSize(maxSize),
         _maxSizeSingleEntry(maxSizeSingleEntry),
@@ -398,28 +398,28 @@ class FlexibleCache {
   EntryList _entries;
   AccessUpdater _accessUpdater;
   ScoreCalculator _scoreCalculator;
-  ValueSizeGetter _valueSizeGetter;
+  ValueSizeGetterT _valueSizeGetter;
   PinnedMap _pinnedMap;
   AccessMap _accessMap;
 };
 
 // Partial instantiation of FlexibleCache using the heap-based priority queue
 // from ad_utility::HeapBasedPQ
-template <class Key, class Value, typename Score, typename ScoreComparator,
-          typename AccessUpdater, typename ScoreCalculator,
-          ValueSizeGetter<Value> ValueSizeGetter>
-using HeapBasedCache =
+CPP_template(class Key, class Value, typename Score, typename ScoreComparator,
+             typename AccessUpdater, typename ScoreCalculator,
+             typename ValueSizeGetterT)(
+    requires ValueSizeGetter<ValueSizeGetterT, Value>) using HeapBasedCache =
     ad_utility::FlexibleCache<HeapBasedPQ, Key, Value, Score, ScoreComparator,
-                              AccessUpdater, ScoreCalculator, ValueSizeGetter>;
+                              AccessUpdater, ScoreCalculator, ValueSizeGetterT>;
 
 // Partial instantiation of FlexibleCache using the tree-based priority queue
 // from ad_utility::TreeBasedPQ
-template <class Key, class Value, typename Score, typename ScoreComparator,
-          typename AccessUpdater, typename ScoreCalculator,
-          ValueSizeGetter<Value> ValueSizeGetter>
-using TreeBasedCache =
+CPP_template(class Key, class Value, typename Score, typename ScoreComparator,
+             typename AccessUpdater, typename ScoreCalculator,
+             typename ValueSizeGetterT)(
+    requires ValueSizeGetter<ValueSizeGetterT, Value>) using TreeBasedCache =
     ad_utility::FlexibleCache<TreeBasedPQ, Key, Value, Score, ScoreComparator,
-                              AccessUpdater, ScoreCalculator, ValueSizeGetter>;
+                              AccessUpdater, ScoreCalculator, ValueSizeGetterT>;
 
 namespace detail {
 // helper types used to implement an LRU cache using the FlexibleCache
@@ -443,37 +443,39 @@ struct timeUpdater {
 }  // namespace detail
 
 /// A LRU cache using the HeapBasedCache
-template <typename Key, typename Value, ValueSizeGetter<Value> ValueSizeGetter>
-class HeapBasedLRUCache
+CPP_template(typename Key, typename Value, typename ValueSizeGetterT)(
+    requires ValueSizeGetter<ValueSizeGetterT, Value>) class HeapBasedLRUCache
     : public HeapBasedCache<Key, Value, detail::TimePoint, std::less<>,
                             detail::timeUpdater, detail::timeAsScore,
-                            ValueSizeGetter> {
-  using Base =
-      HeapBasedCache<Key, Value, detail::TimePoint, std::less<>,
-                     detail::timeUpdater, detail::timeAsScore, ValueSizeGetter>;
+                            ValueSizeGetterT> {
+  using Base = HeapBasedCache<Key, Value, detail::TimePoint, std::less<>,
+                              detail::timeUpdater, detail::timeAsScore,
+                              ValueSizeGetterT>;
 
  public:
   explicit HeapBasedLRUCache(size_t capacityNumEls = size_t_max,
                              MemorySize capacitySize = MemorySize::max(),
                              MemorySize maxSizeSingleEl = MemorySize::max())
       : Base(capacityNumEls, capacitySize, maxSizeSingleEl, std::less<>(),
-             detail::timeUpdater{}, detail::timeAsScore{}, ValueSizeGetter{}) {}
+             detail::timeUpdater{}, detail::timeAsScore{}, ValueSizeGetterT{}) {
+  }
 };
 
 /// A LRU cache using the TreeBasedCache
-template <typename Key, typename Value, ValueSizeGetter<Value> ValueSizeGetter>
-class TreeBasedLRUCache
+CPP_template(typename Key, typename Value, typename ValueSizeGetterT)(
+    requires ValueSizeGetter<ValueSizeGetterT, Value>) class TreeBasedLRUCache
     : public ad_utility::TreeBasedCache<Key, Value, detail::TimePoint,
                                         std::less<>, detail::timeUpdater,
-                                        detail::timeAsScore, ValueSizeGetter> {
-  using Base = ad_utility::TreeBasedCache<Key, Value, detail::TimePoint,
-                                          std::less<>, detail::timeUpdater,
-                                          detail::timeAsScore, ValueSizeGetter>;
+                                        detail::timeAsScore, ValueSizeGetterT> {
+  using Base =
+      ad_utility::TreeBasedCache<Key, Value, detail::TimePoint, std::less<>,
+                                 detail::timeUpdater, detail::timeAsScore,
+                                 ValueSizeGetterT>;
 
  public:
   explicit TreeBasedLRUCache(size_t capacity)
       : Base(capacity, std::less<>(), detail::timeUpdater{},
-             detail::timeAsScore{}, ValueSizeGetter{}) {}
+             detail::timeAsScore{}, ValueSizeGetterT{}) {}
 };
 
 /// typedef for the simple name LRUCache that is fixed to one of the possible
@@ -482,8 +484,9 @@ class TreeBasedLRUCache
 template <typename Key, typename Value, ValueSizeGetter<Value> ValueSizeGetter>
 using LRUCache = TreeBasedLRUCache<Key, Value, ValueSizeGetter>;
 #else
-template <typename Key, typename Value, ValueSizeGetter<Value> ValueSizeGetter>
-using LRUCache = HeapBasedLRUCache<Key, Value, ValueSizeGetter>;
+CPP_template(typename Key, typename Value, typename ValueSizeGetterT)(
+    requires ValueSizeGetter<ValueSizeGetterT, Value>) using LRUCache =
+    HeapBasedLRUCache<Key, Value, ValueSizeGetterT>;
 #endif
 
 }  // namespace ad_utility
diff --git a/src/util/CancellationHandle.cpp b/src/util/CancellationHandle.cpp
index 7f14dab010..b1441f0c36 100644
--- a/src/util/CancellationHandle.cpp
+++ b/src/util/CancellationHandle.cpp
@@ -21,8 +21,8 @@ void CancellationHandle<Mode>::cancel(
 
 // _____________________________________________________________________________
 template <CancellationMode Mode>
-void CancellationHandle<Mode>::startWatchDogInternal() requires WatchDogEnabled
-{
+CPP_member_def auto CancellationHandle<Mode>::startWatchDogInternal()
+    -> CPP_ret(void)(requires WatchDogEnabled) {
   using enum CancellationState;
   std::unique_lock lock{watchDogState_.mutex_};
   // This function is only supposed to be run once.
@@ -64,8 +64,8 @@ void CancellationHandle<Mode>::startWatchDog() {
 
 // _____________________________________________________________________________
 template <CancellationMode Mode>
-void CancellationHandle<Mode>::setStatePreservingCancel(
-    CancellationState newState) requires CancellationEnabled {
+CPP_member_def auto CancellationHandle<Mode>::setStatePreservingCancel(
+    CancellationState newState) -> CPP_ret(void)(requires CancellationEnabled) {
   CancellationState state = cancellationState_.load(std::memory_order_relaxed);
   while (!detail::isCancelled(state)) {
     if (cancellationState_.compare_exchange_weak(state, newState,
diff --git a/src/util/CancellationHandle.h b/src/util/CancellationHandle.h
index 28a445684c..bf986bdfec 100644
--- a/src/util/CancellationHandle.h
+++ b/src/util/CancellationHandle.h
@@ -156,11 +156,15 @@ class CancellationHandle {
   /// in the console that would otherwise be triggered by the watchdog.
   /// NOTE: The parameter state is expected to be one of `CHECK_WINDOW_MISSED`
   /// or `WAITING_FOR_CHECK`, otherwise it will violate the correctness check.
-  void pleaseWatchDog(CancellationState state,
-                      ad_utility::source_location location,
-                      const ad_utility::InvocableWithConvertibleReturnType<
-                          std::string_view> auto& stageInvocable)
-      requires WatchDogEnabled {
+  CPP_template(typename StateFunc)(
+      requires WatchDogEnabled CPP_and
+          ad_utility::InvocableWithConvertibleReturnType<
+              StateFunc,
+              std::string_view>) void pleaseWatchDog(CancellationState state,
+                                                     ad_utility::source_location
+                                                         location,
+                                                     const StateFunc&
+                                                         stageInvocable) {
     using DurationType =
         std::remove_const_t<decltype(DESIRED_CANCELLATION_CHECK_INTERVAL)>;
     AD_CORRECTNESS_CHECK(!detail::isCancelled(state) &&
@@ -199,12 +203,14 @@ class CancellationHandle {
   /// Internal function that starts the watch dog. It will set this
   /// `CancellationHandle` instance into a state that will log a warning in the
   /// console if `throwIfCancelled` is not called frequently enough.
-  void startWatchDogInternal() requires WatchDogEnabled;
+  CPP_member auto startWatchDogInternal()
+      -> CPP_ret(void)(requires WatchDogEnabled);
 
   /// Helper function that sets the internal state atomically given that it has
   /// not been cancelled yet. Otherwise no-op.
-  void setStatePreservingCancel(CancellationState newState)
-      requires CancellationEnabled;
+  /// CPP_member auto
+  CPP_member auto setStatePreservingCancel(CancellationState newState)
+      -> CPP_ret(void)(requires CancellationEnabled);
 
  public:
   /// Sets the cancellation flag so the next call to throwIfCancelled will
@@ -215,12 +221,13 @@ class CancellationHandle {
   /// nothing otherwise. If `WatchDogEnabled` is true, this will log a warning
   /// if this check is not called frequently enough. It will contain the
   /// filename and line of the caller of this method.
-  template <ad_utility::InvocableWithConvertibleReturnType<std::string_view>
-                Func = decltype(detail::printNothing)>
-  AD_ALWAYS_INLINE void throwIfCancelled(
-      [[maybe_unused]] ad_utility::source_location location =
-          ad_utility::source_location::current(),
-      const Func& stageInvocable = detail::printNothing) {
+  CPP_template(typename Func = decltype(detail::printNothing))(
+      requires ad_utility::InvocableWithConvertibleReturnType<Func,
+                                                              std::string_view>)
+      AD_ALWAYS_INLINE void throwIfCancelled(
+          [[maybe_unused]] ad_utility::source_location location =
+              ad_utility::source_location::current(),
+          const Func& stageInvocable = detail::printNothing) {
     if constexpr (CancellationEnabled) {
       auto state = cancellationState_.load(std::memory_order_relaxed);
       if (state == CancellationState::NOT_CANCELLED) [[likely]] {
diff --git a/src/util/ChunkedForLoop.h b/src/util/ChunkedForLoop.h
index 97d2efff93..1fc08affd8 100644
--- a/src/util/ChunkedForLoop.h
+++ b/src/util/ChunkedForLoop.h
@@ -30,12 +30,13 @@ using SetIndexToEndAction =
 /// True if `Func` has a signature of `* func(size_t, const auto&)`
 /// where `*` can be any type. False otherwise.
 template <typename Func>
-concept IteratorWithBreak = std::invocable<Func, size_t, SetIndexToEndAction>;
+CPP_concept IteratorWithBreak =
+    std::invocable<Func, size_t, SetIndexToEndAction>;
 
 /// Helper concept that allows `chunkedForLoop` to offer an action with an
 /// optional second argument in `action`.
 template <typename Func>
-concept IteratorAction =
+CPP_concept IteratorAction =
     std::is_invocable_v<Func, std::size_t> || IteratorWithBreak<Func>;
 }  // namespace detail
 
@@ -45,10 +46,12 @@ concept IteratorAction =
 /// the next iteration, similar to the break keyword. `chunkOperation` is called
 /// every `CHUNK_SIZE` iteration steps, and at least a single time at the end if
 /// the range is not empty.
-template <std::size_t CHUNK_SIZE, detail::IteratorAction Action>
-inline void chunkedForLoop(std::size_t start, std::size_t end,
-                           const Action& action,
-                           const std::invocable auto& chunkOperation) {
+CPP_template(std::size_t CHUNK_SIZE, typename Action)(
+    requires detail::IteratorAction<
+        Action>) inline void chunkedForLoop(std::size_t start, std::size_t end,
+                                            const Action& action,
+                                            const std::invocable auto&
+                                                chunkOperation) {
   static_assert(CHUNK_SIZE != 0, "Chunk size must be non-zero");
   using std::size_t;
   while (start < end) {
@@ -67,17 +70,22 @@ inline void chunkedForLoop(std::size_t start, std::size_t end,
 
 // Helper concept that combines the sized range and input range concepts.
 template <typename R>
-concept SizedInputRange =
+CPP_concept SizedInputRange =
     ql::ranges::sized_range<R> && ql::ranges::input_range<R>;
 
 // Similar to `ql::ranges::copy`, but invokes `chunkOperation` every
 // `chunkSize` elements. (Round up to the next chunk size if the range size is
 // not a multiple of `chunkSize`.)
-template <SizedInputRange R, std::weakly_incrementable O>
-inline void chunkedCopy(R&& inputRange, O result,
-                        ql::ranges::range_difference_t<R> chunkSize,
-                        const std::invocable auto& chunkOperation)
-    requires std::indirectly_copyable<ql::ranges::iterator_t<R>, O> {
+CPP_template(typename R, typename O, typename ChunkOperationFunc)(
+    requires SizedInputRange<R> CPP_and std::weakly_incrementable<O> CPP_and
+        std::invocable<ChunkOperationFunc>
+            CPP_and std::indirectly_copyable<
+                ql::ranges::iterator_t<R>,
+                O>) inline void chunkedCopy(R&& inputRange, O result,
+                                            ql::ranges::range_difference_t<R>
+                                                chunkSize,
+                                            const ChunkOperationFunc&
+                                                chunkOperation) {
   auto begin = ql::ranges::begin(inputRange);
   auto end = ql::ranges::end(inputRange);
   auto target = result;
@@ -93,16 +101,21 @@ inline void chunkedCopy(R&& inputRange, O result,
 
 // Helper concept that combines the sized range and output range concepts.
 template <typename R, typename T>
-concept SizedOutputRange =
+CPP_concept SizedOutputRange =
     ql::ranges::sized_range<R> && ql::ranges::output_range<R, T>;
 
 // Similar to `ql::ranges::fill`, but invokes `chunkOperation` every
 // `chunkSize` elements. (Round up to the next chunk size if the range size is
 // not a multiple of `chunkSize`.)
-template <typename T, SizedOutputRange<T> R>
-inline void chunkedFill(R&& outputRange, const T& value,
-                        ql::ranges::range_difference_t<R> chunkSize,
-                        const std::invocable auto& chunkOperation) {
+CPP_template(typename T, typename R, typename ChunkOperationFunc)(
+    requires SizedOutputRange<R, T> CPP_and std::invocable<
+        ChunkOperationFunc>) inline void chunkedFill(R&& outputRange,
+                                                     const T& value,
+                                                     ql::ranges::
+                                                         range_difference_t<R>
+                                                             chunkSize,
+                                                     const ChunkOperationFunc&
+                                                         chunkOperation) {
   auto begin = ql::ranges::begin(outputRange);
   auto end = ql::ranges::end(outputRange);
   while (ql::ranges::distance(begin, end) >= chunkSize) {
diff --git a/src/util/CompressionUsingZstd/ZstdWrapper.h b/src/util/CompressionUsingZstd/ZstdWrapper.h
index a582370f11..7f7e6fbfb6 100644
--- a/src/util/CompressionUsingZstd/ZstdWrapper.h
+++ b/src/util/CompressionUsingZstd/ZstdWrapper.h
@@ -24,10 +24,10 @@ class ZstdWrapper {
 
   // Decompress the given byte array, assuming that the size of the decompressed
   // data is known.
-  template <typename T>
-  requires(std::is_trivially_copyable_v<T>)
-  static std::vector<T> decompress(void* src, size_t numBytes,
-                                   size_t knownOriginalSize) {
+  CPP_template(typename T)(
+      requires(std::is_trivially_copyable_v<
+               T>)) static std::vector<T> decompress(void* src, size_t numBytes,
+                                                     size_t knownOriginalSize) {
     knownOriginalSize *= sizeof(T);
     std::vector<T> result(knownOriginalSize / sizeof(T));
     auto compressedSize =
@@ -38,10 +38,10 @@ class ZstdWrapper {
 
   // Decompress the given byte array to the given buffer of the given size,
   // returning the number of bytes of the decompressed data.
-  template <typename T>
-  requires(std::is_trivially_copyable_v<T>)
-  static size_t decompressToBuffer(const char* src, size_t numBytes, T* buffer,
-                                   size_t bufferCapacity) {
+  CPP_template(typename T)(
+      requires(std::is_trivially_copyable_v<T>)) static size_t
+      decompressToBuffer(const char* src, size_t numBytes, T* buffer,
+                         size_t bufferCapacity) {
     auto decompressedSize =
         ZSTD_decompress(buffer, bufferCapacity, src, numBytes);
     if (ZSTD_isError(decompressedSize)) {
diff --git a/src/util/Concepts.h b/src/util/Concepts.h
index c6bb4384eb..544ef089ab 100644
--- a/src/util/Concepts.h
+++ b/src/util/Concepts.h
@@ -6,11 +6,21 @@
 
 #include <sstream>
 
+#include "backports/concepts.h"
+
 namespace ad_utility {
+
+namespace detail {
+template <typename T>
+CPP_requires(is_streamable_, requires(T x, std::ostream& os)(os << x));
+}
+
 /**
  * A concept to ensure objects can be formatted by std::ostream.
  * @tparam T The Type to be formatted
  */
+// TODO<joka921, gpcicciuca> turn back to `CPP_concept` and fix the remaining
+// places.
 template <typename T>
-concept Streamable = requires(T x, std::ostream& os) { os << x; };
+concept Streamable = CPP_requires_ref(detail::is_streamable_, T);
 }  // namespace ad_utility
diff --git a/src/util/ConfigManager/ConfigManager.cpp b/src/util/ConfigManager/ConfigManager.cpp
index 148a9264ca..f1f03cf73d 100644
--- a/src/util/ConfigManager/ConfigManager.cpp
+++ b/src/util/ConfigManager/ConfigManager.cpp
@@ -46,8 +46,10 @@ ConfigManager::HashMapEntry::HashMapEntry(Data&& data)
     : data_{std::make_unique<Data>(std::move(data))} {}
 
 // ____________________________________________________________________________
-template <SameAsAnyTypeIn<ConfigManager::HashMapEntry::Data> T>
-bool ConfigManager::HashMapEntry::implHolds() const {
+CPP_template_def(typename T)(
+    requires SameAsAnyTypeIn<
+        T, ConfigManager::HashMapEntry::Data>) bool ConfigManager::
+    HashMapEntry::implHolds() const {
   // Make sure, that it is not a null pointer.
   AD_CORRECTNESS_CHECK(data_);
 
@@ -65,10 +67,13 @@ bool ConfigManager::HashMapEntry::holdsSubManager() const {
 }
 
 // ____________________________________________________________________________
-template <SimilarToAnyTypeIn<ConfigManager::HashMapEntry::Data> ReturnType>
-requires std::is_object_v<ReturnType> std::optional<ReturnType*>
-ConfigManager::HashMapEntry::getConfigOptionOrSubManager(
-    ad_utility::SimilarTo<ConfigManager::HashMapEntry> auto& instance) {
+CPP_template_def(typename ReturnType, typename InstanceType)(
+    requires SimilarToAnyTypeIn<ReturnType, ConfigManager::HashMapEntry::Data>
+        CPP_and_def std::is_object_v<ReturnType>
+            CPP_and_def ad_utility::SimilarTo<ConfigManager::HashMapEntry,
+                                              InstanceType>)
+    std::optional<ReturnType*> ConfigManager::HashMapEntry::
+        getConfigOptionOrSubManager(InstanceType& instance) {
   using DecayReturnType = std::decay_t<ReturnType>;
   /*
   We cheat a bit, by using `implHolds`, because so we can reduce the amount
@@ -105,32 +110,31 @@ std::optional<const ConfigManager*> ConfigManager::HashMapEntry::getSubManager()
 }
 
 // ____________________________________________________________________________
-template <typename Visitor>
-requires std::invocable<Visitor, ConfigOption&> &&
-         std::invocable<Visitor, ConfigManager&>
-decltype(auto) ConfigManager::HashMapEntry::visit(Visitor&& vis) {
+CPP_template_def(typename Visitor)(
+    requires std::invocable<Visitor, ConfigOption&> CPP_and_def
+        std::invocable<Visitor, ConfigManager&>) decltype(auto)
+    ConfigManager::HashMapEntry::visit(Visitor&& vis) {
   return visitImpl(AD_FWD(vis), data_);
 }
-template <typename Visitor>
-requires std::invocable<Visitor, const ConfigOption&> &&
-         std::invocable<Visitor, const ConfigManager&>
-decltype(auto) ConfigManager::HashMapEntry::visit(Visitor&& vis) const {
+CPP_template_def(typename Visitor)(
+    requires std::invocable<Visitor, ConfigOption&> CPP_and_def
+        std::invocable<Visitor, ConfigManager&>) decltype(auto)
+    ConfigManager::HashMapEntry::visit(Visitor&& vis) const {
   return visitImpl(AD_FWD(vis), data_);
 }
 
 // ____________________________________________________________________________
-template <
-    typename Visitor,
-    ad_utility::SimilarTo<std::unique_ptr<ConfigManager::HashMapEntry::Data>>
-        PointerType>
-requires std::invocable<
-             Visitor, std::conditional_t<std::is_const_v<PointerType>,
-                                         const ConfigOption&, ConfigOption&>> &&
-         std::invocable<
-             Visitor, std::conditional_t<std::is_const_v<PointerType>,
-                                         const ConfigManager&, ConfigManager&>>
-decltype(auto) ConfigManager::HashMapEntry::visitImpl(Visitor&& vis,
-                                                      PointerType& data) {
+CPP_template_def(typename Visitor, typename PointerType)(
+    requires ad_utility::SimilarTo<
+        std::unique_ptr<ConfigManager::HashMapEntry::Data>, PointerType>
+        CPP_and_def std::invocable<
+            Visitor, std::conditional_t<std::is_const_v<PointerType>,
+                                        const ConfigOption&, ConfigOption&>>
+            CPP_and_def std::invocable<
+                Visitor, std::conditional_t<std::is_const_v<PointerType>,
+                                            const ConfigManager&,
+                                            ConfigManager&>>) decltype(auto)
+    ConfigManager::HashMapEntry::visitImpl(Visitor&& vis, PointerType& data) {
   // Make sure, that it is not a null pointer.
   AD_CORRECTNESS_CHECK(data);
 
@@ -151,13 +155,14 @@ void ConfigManager::verifyHashMapEntry(std::string_view jsonPathToEntry,
 }
 
 // ____________________________________________________________________________
-template <typename Visitor>
-requires ad_utility::InvocableWithExactReturnType<
-             Visitor, void, std::string_view, ConfigManager&> &&
-         ad_utility::InvocableWithExactReturnType<
-             Visitor, void, std::string_view, ConfigOption&>
-void ConfigManager::visitHashMapEntries(Visitor&& vis, bool sortByCreationOrder,
-                                        std::string_view pathPrefix) const {
+CPP_template_def(typename Visitor)(
+    requires ad_utility::InvocableWithExactReturnType<
+        Visitor, void, std::string_view, ConfigManager&>
+        CPP_and_def ad_utility::InvocableWithExactReturnType<
+            Visitor, void, std::string_view,
+            ConfigOption&>) void ConfigManager::
+    visitHashMapEntries(Visitor&& vis, bool sortByCreationOrder,
+                        std::string_view pathPrefix) const {
   // For less code duplication.
   using Pair = decltype(configurationOptions_)::value_type;
 
@@ -189,17 +194,18 @@ void ConfigManager::visitHashMapEntries(Visitor&& vis, bool sortByCreationOrder,
 }
 
 // ____________________________________________________________________________
-template <
-    SimilarTo<ad_utility::HashMap<std::string, ConfigManager::HashMapEntry>>
+CPP_template_def(typename HashMapType, typename Callable)(
+    requires SimilarTo<
+        ad_utility::HashMap<std::string, ConfigManager::HashMapEntry>,
         HashMapType>
-requires std::is_object_v<HashMapType> auto ConfigManager::allHashMapEntries(
-    HashMapType& hashMap, std::string_view pathPrefix,
-    const ad_utility::InvocableWithSimilarReturnType<
-        bool, const HashMapEntry&> auto& predicate)
-    -> std::conditional_t<
-        std::is_const_v<HashMapType>,
-        const std::vector<std::pair<const std::string, const HashMapEntry&>>,
-        std::vector<std::pair<std::string, HashMapEntry&>>> {
+        CPP_and_def std::is_object_v<HashMapType>) auto ConfigManager::
+    allHashMapEntries(HashMapType& hashMap, std::string_view pathPrefix,
+                      const Callable& predicate)
+        -> std::conditional_t<
+            std::is_const_v<HashMapType>,
+            const std::vector<
+                std::pair<const std::string, const HashMapEntry&>>,
+            std::vector<std::pair<std::string, HashMapEntry&>>> {
   std::conditional_t<
       std::is_const_v<HashMapType>,
       std::vector<std::pair<const std::string, const HashMapEntry&>>,
@@ -256,12 +262,13 @@ requires std::is_object_v<HashMapType> auto ConfigManager::allHashMapEntries(
 }
 
 // ____________________________________________________________________________
-template <QL_CONCEPT_OR_TYPENAME(SameAsAny<ConfigOption&, const ConfigOption&>)
-              ReturnReference>
-std::vector<std::pair<std::string, ReturnReference>>
-ConfigManager::configurationOptionsImpl(
-    SimilarTo<ad_utility::HashMap<std::string, HashMapEntry>> auto&
-        configurationOptions) {
+CPP_template_def(typename ConfigOptions, typename ReturnReference)(
+    requires SameAsAny<ReturnReference, ConfigOption&, const ConfigOption&>
+        CPP_and_def SimilarTo<
+            ad_utility::HashMap<std::string, ConfigManager::HashMapEntry>,
+            ConfigOptions>)
+    std::vector<std::pair<std::string, ReturnReference>> ConfigManager::
+        configurationOptionsImpl(ConfigOptions& configurationOptions) {
   return ad_utility::transform(
       allHashMapEntries(
           configurationOptions, "",
@@ -275,13 +282,15 @@ ConfigManager::configurationOptionsImpl(
 // ____________________________________________________________________________
 std::vector<std::pair<std::string, ConfigOption&>>
 ConfigManager::configurationOptions() {
-  return configurationOptionsImpl<ConfigOption&>(configurationOptions_);
+  return configurationOptionsImpl<decltype(configurationOptions_),
+                                  ConfigOption&>(configurationOptions_);
 }
 
 // ____________________________________________________________________________
 std::vector<std::pair<std::string, const ConfigOption&>>
 ConfigManager::configurationOptions() const {
-  return configurationOptionsImpl<const ConfigOption&>(configurationOptions_);
+  return configurationOptionsImpl<const decltype(configurationOptions_),
+                                  const ConfigOption&>(configurationOptions_);
 }
 
 // ____________________________________________________________________________
@@ -858,9 +867,10 @@ bool ConfigManager::containsOption(const ConfigOption& opt) const {
 }
 
 // ____________________________________________________________________________
-template <QL_CONCEPT_OR_TYPENAME(ConfigOptionOrManager) T>
-void ConfigManager::ConfigurationDocValidatorAssignment::addEntryUnderKey(
-    const T& key, const ConfigOptionValidatorManager& manager) {
+CPP_template_def(typename T)(
+    requires ConfigOptionOrManager<T>) void ConfigManager::
+    ConfigurationDocValidatorAssignment::addEntryUnderKey(
+        const T& key, const ConfigOptionValidatorManager& manager) {
   getHashMapBasedOnType<T>()[&key].push_back(&manager);
 }
 // Explicit instantiation for `ConfigOption` and `ConfigManager`.
@@ -872,9 +882,10 @@ template void ConfigManager::ConfigurationDocValidatorAssignment::
                                     const ConfigOptionValidatorManager&);
 
 // ____________________________________________________________________________
-template <QL_CONCEPT_OR_TYPENAME(ConfigOptionOrManager) T>
-auto ConfigManager::ConfigurationDocValidatorAssignment::getEntriesUnderKey(
-    const T& key) const -> ValueGetterReturnType {
+CPP_template_def(typename T)(
+    requires ConfigOptionOrManager<T>) auto ConfigManager::
+    ConfigurationDocValidatorAssignment::getEntriesUnderKey(const T& key) const
+    -> ValueGetterReturnType {
   // The concerned hash map.
   const MemoryAdressHashMap<T>& hashMap{getHashMapBasedOnType<T>()};
 
diff --git a/src/util/ConfigManager/ConfigManager.h b/src/util/ConfigManager/ConfigManager.h
index 48691e96c5..275639fbb5 100644
--- a/src/util/ConfigManager/ConfigManager.h
+++ b/src/util/ConfigManager/ConfigManager.h
@@ -89,19 +89,19 @@ class ConfigManager {
     size_t getInitializationId() const;
 
     // Wrapper for calling `std::visit` on the saved `Data`.
-    template <typename Visitor>
-    requires std::invocable<Visitor, ConfigOption&> &&
-             std::invocable<Visitor, ConfigManager&>
-    decltype(auto) visit(Visitor&& vis);
-    template <typename Visitor>
-    requires std::invocable<Visitor, const ConfigOption&> &&
-             std::invocable<Visitor, const ConfigManager&>
-    decltype(auto) visit(Visitor&& vis) const;
+    CPP_template(typename Visitor)(
+        requires std::invocable<Visitor, ConfigOption&> CPP_and
+            std::invocable<Visitor, ConfigManager&>) decltype(auto)
+        visit(Visitor&& vis);
+    CPP_template(typename Visitor)(
+        requires std::invocable<Visitor, ConfigOption&> CPP_and
+            std::invocable<Visitor, ConfigManager&>) decltype(auto)
+        visit(Visitor&& vis) const;
 
    private:
     // Implementation for `holdsConfigOption` and `holdsSubManager`.
-    template <SameAsAnyTypeIn<Data> T>
-    bool implHolds() const;
+    CPP_template(typename T)(
+        requires SameAsAnyTypeIn<T, Data>) bool implHolds() const;
 
     /*
     @brief Implementation for `getConfigOption` and `getSubManager`. You can
@@ -113,25 +113,30 @@ class ConfigManager {
     @SameAsAny<const ConfigOption&, ConfigOption& >m instance The `HashMapEntry`
     you want this from.
     */
-    template <SimilarToAnyTypeIn<Data> ReturnType>
-    requires std::is_object_v<ReturnType>
-    static std::optional<ReturnType*> getConfigOptionOrSubManager(
-        ad_utility::SimilarTo<HashMapEntry> auto& instance);
+    CPP_template(typename ReturnType, typename InstanceType)(
+        requires SimilarToAnyTypeIn<ReturnType, Data> CPP_and
+            std::is_object_v<ReturnType>
+                CPP_and ad_utility::SimilarTo<HashMapEntry,
+                                              InstanceType>) static std::
+        optional<ReturnType*> getConfigOptionOrSubManager(
+            InstanceType& instance);
 
     /*
     @brief The implementation for `visit`. Follows the same signature as
     `std::variant::visit`:
     */
-    template <typename Visitor, ad_utility::SimilarTo<std::unique_ptr<
-                                    ConfigManager::HashMapEntry::Data>>
-                                    PointerType>
-    requires std::invocable<Visitor, std::conditional_t<
-                                         std::is_const_v<PointerType>,
-                                         const ConfigOption&, ConfigOption&>> &&
-             std::invocable<Visitor, std::conditional_t<
-                                         std::is_const_v<PointerType>,
-                                         const ConfigManager&, ConfigManager&>>
-    static decltype(auto) visitImpl(Visitor&& vis, PointerType& data);
+    CPP_template(typename Visitor, typename PointerType)(
+        requires ad_utility::SimilarTo<
+            std::unique_ptr<ConfigManager::HashMapEntry::Data>, PointerType>
+            CPP_and std::invocable<
+                Visitor, std::conditional_t<std::is_const_v<PointerType>,
+                                            const ConfigOption&, ConfigOption&>>
+                CPP_and std::invocable<
+                    Visitor,
+                    std::conditional_t<std::is_const_v<PointerType>,
+                                       const ConfigManager&,
+                                       ConfigManager&>>) static decltype(auto)
+        visitImpl(Visitor&& vis, PointerType& data);
   };
 
   /*
@@ -173,11 +178,12 @@ class ConfigManager {
   @return A reference to the newly created configuration option. This reference
   will stay valid, even after adding more options.
   */
-  template <SupportedConfigOptionType OptionType>
-  ConstConfigOptionProxy<OptionType> addOption(
-      const std::vector<std::string>& pathToOption,
-      std::string_view optionDescription,
-      OptionType* variableToPutValueOfTheOptionIn) {
+  CPP_template(typename OptionType)(
+      requires SupportedConfigOptionType<OptionType>)
+      ConstConfigOptionProxy<OptionType> addOption(
+          const std::vector<std::string>& pathToOption,
+          std::string_view optionDescription,
+          OptionType* variableToPutValueOfTheOptionIn) {
     return addOptionImpl(pathToOption, optionDescription,
                          variableToPutValueOfTheOptionIn,
                          std::optional<OptionType>(std::nullopt));
@@ -201,13 +207,14 @@ class ConfigManager {
   @return A reference to the newly created configuration option. This reference
   will stay valid, even after adding more options.
   */
-  template <SupportedConfigOptionType OptionType,
-            std::same_as<OptionType> DefaultValueType = OptionType>
-  ConstConfigOptionProxy<OptionType> addOption(
-      const std::vector<std::string>& pathToOption,
-      std::string_view optionDescription,
-      OptionType* variableToPutValueOfTheOptionIn,
-      DefaultValueType defaultValue) {
+  CPP_template(typename OptionType, typename DefaultValueType = OptionType)(
+      requires SupportedConfigOptionType<OptionType> CPP_and
+          std::same_as<OptionType, DefaultValueType>)
+      ConstConfigOptionProxy<OptionType> addOption(
+          const std::vector<std::string>& pathToOption,
+          std::string_view optionDescription,
+          OptionType* variableToPutValueOfTheOptionIn,
+          DefaultValueType defaultValue) {
     return addOptionImpl(pathToOption, optionDescription,
                          variableToPutValueOfTheOptionIn,
                          std::optional<OptionType>(std::move(defaultValue)));
@@ -221,10 +228,11 @@ class ConfigManager {
   @return A reference to the newly created configuration option. This reference
   will stay valid, even after adding more options.
   */
-  template <SupportedConfigOptionType OptionType>
-  ConstConfigOptionProxy<OptionType> addOption(
-      std::string optionName, std::string_view optionDescription,
-      OptionType* variableToPutValueOfTheOptionIn) {
+  CPP_template(typename OptionType)(
+      requires SupportedConfigOptionType<OptionType>)
+      ConstConfigOptionProxy<OptionType> addOption(
+          std::string optionName, std::string_view optionDescription,
+          OptionType* variableToPutValueOfTheOptionIn) {
     return addOption<OptionType>(
         std::vector<std::string>{std::move(optionName)}, optionDescription,
         variableToPutValueOfTheOptionIn);
@@ -238,12 +246,13 @@ class ConfigManager {
   @return A reference to the newly created configuration option. This reference
   will stay valid, even after adding more options.
   */
-  template <SupportedConfigOptionType OptionType,
-            std::same_as<OptionType> DefaultValueType = OptionType>
-  ConstConfigOptionProxy<OptionType> addOption(
-      std::string optionName, std::string_view optionDescription,
-      OptionType* variableToPutValueOfTheOptionIn,
-      DefaultValueType defaultValue) {
+  CPP_template(typename OptionType, typename DefaultValueType = OptionType)(
+      requires SupportedConfigOptionType<OptionType> CPP_and
+          std::same_as<OptionType, DefaultValueType>)
+      ConstConfigOptionProxy<OptionType> addOption(
+          std::string optionName, std::string_view optionDescription,
+          OptionType* variableToPutValueOfTheOptionIn,
+          DefaultValueType defaultValue) {
     return addOption<OptionType>(
         std::vector<std::string>{std::move(optionName)}, optionDescription,
         variableToPutValueOfTheOptionIn, std::move(defaultValue));
@@ -314,19 +323,24 @@ class ConfigManager {
   values will be passed to the validator function as function arguments. Will
   keep the same order.
   */
-  template <typename... ValidatorParameterTypes>
-  void addValidator(
-      ValidatorFunction<ValidatorParameterTypes...> auto validatorFunction,
-      std::string errorMessage, std::string validatorDescriptor,
-      ConstConfigOptionProxy<
-          ValidatorParameterTypes>... configOptionsToBeChecked)
-      requires(sizeof...(configOptionsToBeChecked) > 0) {
+  CPP_template(typename ValidatorFunc, typename... ValidatorParameterTypes)(
+      requires(sizeof...(ValidatorParameterTypes) > 0) CPP_and ValidatorFunction<
+          ValidatorFunc,
+          ValidatorParameterTypes...>) void addValidator(ValidatorFunc
+                                                             validatorFunction,
+                                                         std::string
+                                                             errorMessage,
+                                                         std::string
+                                                             validatorDescriptor,
+                                                         ConstConfigOptionProxy<
+                                                             ValidatorParameterTypes>... configOptionsToBeChecked) {
     addValidatorImpl(
         "addValidator",
         []<typename T>(ConstConfigOptionProxy<T> opt) {
           return opt.getConfigOption().template getValue<std::decay_t<T>>();
         },
-        transformValidatorIntoExceptionValidator<ValidatorParameterTypes...>(
+        transformValidatorIntoExceptionValidator<ValidatorFunc,
+                                                 ValidatorParameterTypes...>(
             validatorFunction, std::move(errorMessage)),
         std::move(validatorDescriptor), configOptionsToBeChecked...);
   }
@@ -349,14 +363,16 @@ class ConfigManager {
   values of which will be passed to the exception validator function as function
   arguments. Will keep the same order.
   */
-  template <typename... ExceptionValidatorParameterTypes>
-  void addValidator(
-      ExceptionValidatorFunction<ExceptionValidatorParameterTypes...> auto
-          exceptionValidatorFunction,
-      std::string exceptionValidatorDescriptor,
-      ConstConfigOptionProxy<
-          ExceptionValidatorParameterTypes>... configOptionsToBeChecked)
-      requires(sizeof...(configOptionsToBeChecked) > 0) {
+  CPP_template(typename ExceptionalValidatorFunc,
+               typename... ExceptionValidatorParameterTypes)(
+      requires(sizeof...(ExceptionValidatorParameterTypes) > 0) CPP_and ExceptionValidatorFunction<
+          ExceptionalValidatorFunc,
+          ExceptionValidatorParameterTypes...>) void addValidator(ExceptionalValidatorFunc
+                                                                      exceptionValidatorFunction,
+                                                                  std::string
+                                                                      exceptionValidatorDescriptor,
+                                                                  ConstConfigOptionProxy<
+                                                                      ExceptionValidatorParameterTypes>... configOptionsToBeChecked) {
     addValidatorImpl(
         "addValidator",
         []<typename T>(ConstConfigOptionProxy<T> opt) {
@@ -380,21 +396,23 @@ class ConfigManager {
   will be passed to the validator function as function arguments. Will keep the
   same order.
   */
-  template <typename ValidatorT>
-  void addOptionValidator(
-      ValidatorT validatorFunction, std::string errorMessage,
-      std::string validatorDescriptor,
-      isInstantiation<ConstConfigOptionProxy> auto... configOptionsToBeChecked)
-      requires(
-          sizeof...(configOptionsToBeChecked) > 0 &&
-          ValidatorFunction<ValidatorT, decltype(configOptionsToBeChecked
-                                                     .getConfigOption())...>) {
+  CPP_template(typename ValidatorFunc, typename... ConfigOptions)(requires(
+      sizeof...(ConfigOptions) >
+      0)) auto addOptionValidator(ValidatorFunc validatorFunction,
+                                  std::string errorMessage,
+                                  std::string validatorDescriptor,
+                                  ConfigOptions&&... configOptionsToBeChecked)
+      -> CPP_ret(void)(
+          requires(ValidatorFunction<
+                   ValidatorFunc,
+                   decltype(configOptionsToBeChecked.getConfigOption())...>)) {
     addValidatorImpl(
         "addOptionValidator",
         []<typename T>(ConstConfigOptionProxy<T> opt) {
           return opt.getConfigOption();
         },
         transformValidatorIntoExceptionValidator<
+            ValidatorFunc,
             decltype(configOptionsToBeChecked.getConfigOption())...>(
             validatorFunction, std::move(errorMessage)),
         std::move(validatorDescriptor), configOptionsToBeChecked...);
@@ -414,15 +432,17 @@ class ConfigManager {
   will be passed to the validator function as function arguments. Will keep the
   same order.
   */
-  template <typename ExceptionValidatorT>
-  void addOptionValidator(
-      ExceptionValidatorT exceptionValidatorFunction,
-      std::string exceptionValidatorDescriptor,
-      isInstantiation<ConstConfigOptionProxy> auto... configOptionsToBeChecked)
-      requires(sizeof...(configOptionsToBeChecked) > 0 &&
-               ExceptionValidatorFunction<
+  CPP_template(typename ExceptionValidatorT,
+               typename... ConfigOptions)(requires(
+      sizeof...(ConfigOptions) >
+      0)) auto addOptionValidator(ExceptionValidatorT
+                                      exceptionValidatorFunction,
+                                  std::string exceptionValidatorDescriptor,
+                                  ConfigOptions&&... configOptionsToBeChecked)
+      -> CPP_ret(void)(
+          requires(ExceptionValidatorFunction<
                    ExceptionValidatorT,
-                   decltype(configOptionsToBeChecked.getConfigOption())...>) {
+                   decltype(configOptionsToBeChecked.getConfigOption())...>)) {
     addValidatorImpl(
         "addOptionValidator",
         []<typename T>(ConstConfigOptionProxy<T> opt) {
@@ -460,13 +480,15 @@ class ConfigManager {
   path, so that information will only be included in generated error messages,
   if you pass it along.
   */
-  template <typename Visitor>
-  requires ad_utility::InvocableWithExactReturnType<
-               Visitor, void, std::string_view, ConfigManager&> &&
-           ad_utility::InvocableWithExactReturnType<
-               Visitor, void, std::string_view, ConfigOption&>
-  void visitHashMapEntries(Visitor&& vis, bool sortByCreationOrder,
-                           std::string_view pathPrefix) const;
+  CPP_template(typename Visitor)(
+      requires ad_utility::InvocableWithExactReturnType<
+          Visitor, void, std::string_view, ConfigManager&>
+          CPP_and ad_utility::InvocableWithExactReturnType<
+              Visitor, void, std::string_view,
+              ConfigOption&>) void visitHashMapEntries(Visitor&& vis,
+                                                       bool sortByCreationOrder,
+                                                       std::string_view
+                                                           pathPrefix) const;
 
   /*
   @brief Collect all `HashMapEntry` contained in the `hashMap`, including the
@@ -479,15 +501,20 @@ class ConfigManager {
   @param predicate Only the `HashMapEntry` for which a true is returned, will be
   given back.
   */
-  template <
-      SimilarTo<ad_utility::HashMap<std::string, HashMapEntry>> HashMapType>
-  requires std::is_object_v<HashMapType> static std::conditional_t<
-      std::is_const_v<HashMapType>,
-      const std::vector<std::pair<const std::string, const HashMapEntry&>>,
-      std::vector<std::pair<std::string, HashMapEntry&>>>
-  allHashMapEntries(HashMapType& hashMap, std::string_view pathPrefix,
-                    const ad_utility::InvocableWithSimilarReturnType<
-                        bool, const HashMapEntry&> auto& predicate);
+  CPP_template(typename HashMapType, typename Callable)(
+      requires SimilarTo<ad_utility::HashMap<std::string, HashMapEntry>,
+                         HashMapType>
+          CPP_and std::is_object_v<HashMapType>) static std::
+      conditional_t<
+          std::is_const_v<HashMapType>,
+          const std::vector<std::pair<const std::string, const HashMapEntry&>>,
+          std::vector<std::pair<
+              std::string, HashMapEntry&>>> allHashMapEntries(HashMapType&
+                                                                  hashMap,
+                                                              std::string_view
+                                                                  pathPrefix,
+                                                              const Callable&
+                                                                  predicate);
 
   /*
   @brief Creates the string representation of a valid `nlohmann::json` pointer
@@ -540,14 +567,14 @@ class ConfigManager {
   @return A reference to the newly created configuration option. Will stay
   valid, even after more options.
   */
-  template <
-      ad_utility::SameAsAnyTypeIn<ConfigOption::AvailableTypes> OptionType>
-  ConstConfigOptionProxy<OptionType> addOptionImpl(
-      const std::vector<std::string>& pathToOption,
-      std::string_view optionDescription,
-      OptionType* variableToPutValueOfTheOptionIn,
-      std::optional<OptionType> defaultValue =
-          std::optional<OptionType>(std::nullopt)) {
+  CPP_template(typename OptionType)(requires ad_utility::SameAsAnyTypeIn<
+                                    OptionType, ConfigOption::AvailableTypes>)
+      ConstConfigOptionProxy<OptionType> addOptionImpl(
+          const std::vector<std::string>& pathToOption,
+          std::string_view optionDescription,
+          OptionType* variableToPutValueOfTheOptionIn,
+          std::optional<OptionType> defaultValue =
+              std::optional<OptionType>(std::nullopt)) {
     verifyPath(pathToOption);
 
     /*
@@ -580,12 +607,12 @@ class ConfigManager {
   @tparam ReturnReference Should be either `ConfigOption&`, or `const
   ConfigOption&`.
   */
-  template <QL_CONCEPT_OR_TYPENAME(
-      SameAsAny<ConfigOption&, const ConfigOption&>) ReturnReference>
-  static std::vector<std::pair<std::string, ReturnReference>>
-  configurationOptionsImpl(
-      SimilarTo<ad_utility::HashMap<std::string, HashMapEntry>> auto&
-          configurationOptions);
+  CPP_template(typename ConfigOptions, typename ReturnReference)(
+      requires SameAsAny<ReturnReference, ConfigOption&, const ConfigOption&>
+          CPP_and SimilarTo<ad_utility::HashMap<std::string, HashMapEntry>,
+                            ConfigOptions>) static std::
+      vector<std::pair<std::string, ReturnReference>> configurationOptionsImpl(
+          ConfigOptions& configurationOptions);
 
   /*
   @brief Return all `ConfigOptionValidatorManager` held by this manager and its
@@ -629,9 +656,8 @@ class ConfigManager {
   will be passed to the exception validator function as function arguments,
   after being transformed. Will keep the same order.
   */
-  template <
-      typename TranslationFunction, typename ExceptionValidatorFunc,
-      isInstantiation<ConstConfigOptionProxy>... ExceptionValidatorParameter>
+  template <typename TranslationFunction, typename ExceptionValidatorFunc,
+            typename... ExceptionValidatorParameter>
   void addValidatorImpl(
       std::string_view addValidatorFunctionName,
       TranslationFunction translationFunction,
@@ -718,9 +744,11 @@ class ConfigManager {
     @brief Add a validator to the list of validators, that are assigned to a
     `ConfigOption`/`ConfigManager`.
     */
-    template <QL_CONCEPT_OR_TYPENAME(ConfigOptionOrManager) T>
-    void addEntryUnderKey(const T& key,
-                          const ConfigOptionValidatorManager& manager);
+    CPP_template(typename T)(
+        requires ConfigOptionOrManager<
+            T>) void addEntryUnderKey(const T& key,
+                                      const ConfigOptionValidatorManager&
+                                          manager);
 
     /*
     @brief Retrieve the list of validators, that are assigned to a
@@ -728,21 +756,22 @@ class ConfigManager {
 
     @returns If there is no entry for `Key`, return an empty `std::vector`.
     */
-    template <QL_CONCEPT_OR_TYPENAME(ConfigOptionOrManager) T>
-    ValueGetterReturnType getEntriesUnderKey(const T& key) const;
+    CPP_template(typename T)(requires ConfigOptionOrManager<T>)
+        ValueGetterReturnType getEntriesUnderKey(const T& key) const;
 
    private:
     // Return either `configOption_` or `configManager_`, based on type.
-    template <QL_CONCEPT_OR_TYPENAME(ConfigOptionOrManager) T>
-    constexpr const MemoryAdressHashMap<T>& getHashMapBasedOnType() const {
+    CPP_template(typename T)(requires ConfigOptionOrManager<T>) constexpr const
+        MemoryAdressHashMap<T>& getHashMapBasedOnType() const {
       if constexpr (std::same_as<T, ConfigOption>) {
         return configOption_;
       } else if constexpr (std::same_as<T, ConfigManager>) {
         return configManager_;
       }
     }
-    template <QL_CONCEPT_OR_TYPENAME(ConfigOptionOrManager) T>
-    constexpr MemoryAdressHashMap<T>& getHashMapBasedOnType() {
+    CPP_template(typename T)(
+        requires ConfigOptionOrManager<
+            T>) constexpr MemoryAdressHashMap<T>& getHashMapBasedOnType() {
       if constexpr (std::same_as<T, ConfigOption>) {
         return configOption_;
       } else if constexpr (std::same_as<T, ConfigManager>) {
diff --git a/src/util/ConfigManager/ConfigOption.h b/src/util/ConfigManager/ConfigOption.h
index f80fd5183f..4aabcde333 100644
--- a/src/util/ConfigManager/ConfigOption.h
+++ b/src/util/ConfigManager/ConfigOption.h
@@ -91,8 +91,9 @@ class ConfigOption {
   bool wasSet() const;
 
   // Returns, if this configuration option holds values of the given type.
-  template <ad_utility::SameAsAnyTypeIn<ConfigOption::AvailableTypes> Type>
-  constexpr bool holdsType() const {
+  CPP_template(typename Type)(
+      requires ad_utility::SameAsAnyTypeIn<
+          Type, AvailableTypes>) constexpr bool holdsType() const {
     return std::holds_alternative<Data<Type>>(data_);
   }
 
@@ -101,8 +102,8 @@ class ConfigOption {
   exception, should the given value have a different type, than what the
   configuration option was set to.
   */
-  template <ad_utility::SameAsAnyTypeIn<AvailableTypes> T>
-  void setValue(const T& value) {
+  CPP_template(typename T)(requires ad_utility::SameAsAnyTypeIn<
+                           T, AvailableTypes>) void setValue(const T& value) {
     // Only set the variable, that our internal pointer points to, if the given
     // value is of the right type.
     if (auto* data = std::get_if<Data<T>>(&data_); data != nullptr) {
@@ -127,8 +128,9 @@ class ConfigOption {
   there is no default value, or `T` is the wrong type, then it will throw an
   exception.
   */
-  template <ad_utility::SameAsAnyTypeIn<AvailableTypes> T>
-  T getDefaultValue() const {
+  CPP_template(typename T)(
+      requires ad_utility::SameAsAnyTypeIn<T, AvailableTypes>) T
+      getDefaultValue() const {
     if (hasDefaultValue() && std::holds_alternative<Data<T>>(data_)) {
       return std::get<Data<T>>(data_).defaultValue_.value();
     } else if (!hasDefaultValue()) {
@@ -156,8 +158,9 @@ class ConfigOption {
   @brief Return the content of the variable, that the internal pointer points
   to. If `T` is the wrong type, then it will throw an exception.
   */
-  template <ad_utility::SameAsAnyTypeIn<AvailableTypes> T>
-  T getValue() const {
+  CPP_template(typename T)(
+      requires ad_utility::SameAsAnyTypeIn<T, AvailableTypes>) T
+      getValue() const {
     if (wasSet() && std::holds_alternative<Data<T>>(data_)) {
       return *(std::get<Data<T>>(data_).variablePointer_);
     } else if (!wasSet()) {
@@ -212,9 +215,11 @@ class ConfigOption {
   @param defaultValue The optional default value. An empty `std::optional` is
   for no default value and a non empty for a default value.
   */
-  template <ad_utility::SameAsAnyTypeIn<AvailableTypes> T>
-  ConfigOption(std::string_view identifier, std::string_view description,
-               T* variablePointer, std::optional<T> defaultValue = std::nullopt)
+  CPP_template(typename T)(
+      requires ad_utility::SameAsAnyTypeIn<T, AvailableTypes>)
+      ConfigOption(std::string_view identifier, std::string_view description,
+                   T* variablePointer,
+                   std::optional<T> defaultValue = std::nullopt)
       : data_{Data<T>{std::move(defaultValue), variablePointer}},
         identifier_{identifier},
         description_{description} {
@@ -251,8 +256,9 @@ class ConfigOption {
   /*
   @brief Return the string representation/name of the type.
   */
-  template <ad_utility::SameAsAnyTypeIn<AvailableTypes> T>
-  static std::string availableTypesToString() {
+  CPP_template(typename T)(requires ad_utility::SameAsAnyTypeIn<
+                           T, AvailableTypes>) static std::string
+      availableTypesToString() {
     return availableTypesToString(T{});
   }
 
@@ -266,7 +272,7 @@ class ConfigOption {
 
 // Shorthand for checking, if `T` is part of the available options.
 template <typename T>
-concept SupportedConfigOptionType =
+CPP_concept SupportedConfigOptionType =
     ad_utility::SameAsAnyTypeIn<T, ConfigOption::AvailableTypes>;
 }  // namespace ConfigManagerImpl
 using ConfigManagerImpl::ConfigOption;
diff --git a/src/util/ConfigManager/ConfigOptionProxy.h b/src/util/ConfigManager/ConfigOptionProxy.h
index 3050b4fcea..beb5650642 100644
--- a/src/util/ConfigManager/ConfigOptionProxy.h
+++ b/src/util/ConfigManager/ConfigOptionProxy.h
@@ -43,26 +43,26 @@ CPP_template(typename T, typename ConfigOptionType)(
 
   // Get access to the configuration option, this is a proxy for. Const access
   // only for the const version, to make the usage clearer.
-  ConfigOptionType& getConfigOption() const
-      requires std::is_const_v<ConfigOptionType> {
+  const ConfigOptionType& getConfigOption() const
+      QL_CONCEPT_OR_NOTHING(requires(std::is_const_v<ConfigOptionType>)) {
     AD_CORRECTNESS_CHECK(option_ != nullptr);
     return *option_;
   }
 
   ConfigOptionType& getConfigOption()
-      requires(!std::is_const_v<ConfigOptionType>) {
+      QL_CONCEPT_OR_NOTHING(requires(!std::is_const_v<ConfigOptionType>)) {
     AD_CORRECTNESS_CHECK(option_ != nullptr);
     return *option_;
   }
 
   // (Implicit) conversion to `ConfigOptionType&`.
   explicit(false) operator ConfigOptionType&() const
-      requires(std::is_const_v<ConfigOptionType>) {
+      QL_CONCEPT_OR_NOTHING(requires(std::is_const_v<ConfigOptionType>)) {
     return getConfigOption();
   }
 
   explicit(false) operator ConfigOptionType&()
-      requires(!std::is_const_v<ConfigOptionType>) {
+      QL_CONCEPT_OR_NOTHING(requires(!std::is_const_v<ConfigOptionType>)) {
     return getConfigOption();
   }
 };
diff --git a/src/util/ConfigManager/Validator.h b/src/util/ConfigManager/Validator.h
index 8400332b31..d502bcb13f 100644
--- a/src/util/ConfigManager/Validator.h
+++ b/src/util/ConfigManager/Validator.h
@@ -26,7 +26,7 @@ types, in the same order and transformed to `const type&`, and returns a
 bool.
 */
 template <typename Func, typename... ParameterTypes>
-concept ValidatorFunction =
+CPP_concept ValidatorFunction =
     RegularInvocableWithSimilarReturnType<Func, bool, const ParameterTypes&...>;
 
 // Simple struct, that holds an error message. For use as the return type of
@@ -49,7 +49,7 @@ parameter types, in the same order and transformed to `const type&`, and returns
 an instance of `std::optional<ErrorMessage>`.
 */
 template <typename Func, typename... ParameterTypes>
-concept ExceptionValidatorFunction =
+CPP_concept ExceptionValidatorFunction =
     RegularInvocableWithSimilarReturnType<Func, std::optional<ErrorMessage>,
                                           const ParameterTypes&...>;
 
@@ -60,10 +60,13 @@ That is, instead of returning `bool`, it now returns
 
 @param errorMessage Content for `ErrorMessage`.
 */
-template <typename... ValidatorParameterTypes>
-inline auto transformValidatorIntoExceptionValidator(
-    ValidatorFunction<ValidatorParameterTypes...> auto validatorFunction,
-    std::string errorMessage) {
+CPP_template(typename ValidatorFunc, typename... ValidatorParameterTypes)(
+    requires ValidatorFunction<
+        ValidatorFunc,
+        ValidatorParameterTypes...>) inline auto transformValidatorIntoExceptionValidator(ValidatorFunc
+                                                                                              validatorFunction,
+                                                                                          std::string
+                                                                                              errorMessage) {
   // The whole 'transformation' is simply a wrapper.
   return [validatorFunction = std::move(validatorFunction),
           errorMessage = ErrorMessage{std::move(errorMessage)}](
@@ -127,22 +130,21 @@ class ConfigOptionValidatorManager {
   will be passed to the exception validator function as function arguments,
   after being transformed. Will keep the same order.
   */
-  template <typename TranslationFunction, typename ExceptionValidatorFunc,
-            isInstantiation<
-                ConstConfigOptionProxy>... ExceptionValidatorParameterTypes>
-  requires(std::invocable<TranslationFunction,
-                          const ExceptionValidatorParameterTypes> &&
-           ...) &&
-              ExceptionValidatorFunction<
+  CPP_template(typename TranslationFunction, typename ExceptionValidatorFunc,
+               typename... ExceptionValidatorParameterTypes)(
+      requires(...&& isInstantiation<ExceptionValidatorParameterTypes,
+                                     ConstConfigOptionProxy>)
+          CPP_and(...&& std::invocable<TranslationFunction,
+                                       const ExceptionValidatorParameterTypes>)
+              CPP_and ExceptionValidatorFunction<
                   ExceptionValidatorFunc,
                   std::invoke_result_t<
                       TranslationFunction,
-                      const ExceptionValidatorParameterTypes>...> &&
-              (sizeof...(ExceptionValidatorParameterTypes) > 0)
-  ConfigOptionValidatorManager(
-      ExceptionValidatorFunc exceptionValidatorFunction, std::string descriptor,
-      TranslationFunction translationFunction,
-      const ExceptionValidatorParameterTypes... configOptionsToBeChecked)
+                      const ExceptionValidatorParameterTypes>...>)
+      ConfigOptionValidatorManager(
+          ExceptionValidatorFunc exceptionValidatorFunction,
+          std::string descriptor, TranslationFunction translationFunction,
+          const ExceptionValidatorParameterTypes... configOptionsToBeChecked)
       : descriptor_{std::move(descriptor)},
         configOptionsToBeChecked_{
             &configOptionsToBeChecked.getConfigOption()...} {
@@ -194,21 +196,26 @@ class ConfigOptionValidatorManager {
   will be passed to the exception validator function as function arguments,
   after being transformed. Will keep the same order.
   */
-  template <typename TranslationFunction, typename ValidatorFunc,
-            isInstantiation<ConstConfigOptionProxy>... ValidatorParameterTypes>
-  requires(std::invocable<TranslationFunction, const ValidatorParameterTypes> &&
-           ...) &&
-          ValidatorFunction<
-              ValidatorFunc,
-              std::invoke_result_t<TranslationFunction,
-                                   const ValidatorParameterTypes>...> &&
-          (sizeof...(ValidatorParameterTypes) > 0) ConfigOptionValidatorManager(
-      ValidatorFunc validatorFunction, std::string errorMessage,
-      std::string descriptor, TranslationFunction translationFunction,
-      const ValidatorParameterTypes... configOptionsToBeChecked)
+  CPP_template(typename TranslationFunction, typename ValidatorFunc,
+               typename... ValidatorParameterTypes)(
+      requires(...&& isInstantiation<ValidatorParameterTypes,
+                                     ConstConfigOptionProxy>)
+          CPP_and(... && (std::invocable<TranslationFunction,
+                                         const ValidatorParameterTypes>))
+              CPP_and(ValidatorFunction<
+                      ValidatorFunc,
+                      std::invoke_result_t<TranslationFunction,
+                                           const ValidatorParameterTypes>...>)
+                  CPP_and(sizeof...(ValidatorParameterTypes) > 0))
+      ConfigOptionValidatorManager(
+          ValidatorFunc validatorFunction, std::string errorMessage,
+          std::string descriptor, TranslationFunction translationFunction,
+          const ValidatorParameterTypes... configOptionsToBeChecked)
       : ConfigOptionValidatorManager(
-            transformValidatorIntoExceptionValidator<std::invoke_result_t<
-                TranslationFunction, const ValidatorParameterTypes>...>(
+            transformValidatorIntoExceptionValidator<
+                ValidatorFunc,
+                std::invoke_result_t<TranslationFunction,
+                                     const ValidatorParameterTypes>...>(
                 std::move(validatorFunction), std::move(errorMessage)),
             std::move(descriptor), std::move(translationFunction),
             configOptionsToBeChecked...) {}
diff --git a/src/util/ConstexprSmallString.h b/src/util/ConstexprSmallString.h
index ebbe26d5d9..78ca38bd4d 100644
--- a/src/util/ConstexprSmallString.h
+++ b/src/util/ConstexprSmallString.h
@@ -37,7 +37,7 @@ struct ConstexprSmallString {
   }
 
   /// Construct at runtime from a string_view
-  ConstexprSmallString(std::string_view input) : _size(input.size()) {
+  constexpr ConstexprSmallString(std::string_view input) : _size(input.size()) {
     if (input.size() >= MaxSize) {
       throw std::runtime_error{
           "ConstexprSmallString can only be constructed from strings with a "
diff --git a/src/util/ConstexprUtils.h b/src/util/ConstexprUtils.h
index 6661748788..af3ab6d718 100644
--- a/src/util/ConstexprUtils.h
+++ b/src/util/ConstexprUtils.h
@@ -50,25 +50,41 @@ void ConstexprForLoop(const std::index_sequence<ForLoopIndexes...>&,
   ((loopBody.template operator()<ForLoopIndexes>()), ...);
 }
 
+template <typename Func, typename CaseConstant, typename... ArgTypes>
+CPP_requires(
+    is_invocable_with_case_,
+    requires(Func&& f, ArgTypes&&... args)(
+        AD_FWD(f).template operator()<CaseConstant::value>(AD_FWD(args)...)));
+
+// Concept that checks if a function can be called with the given arguments
+template <typename Func, auto Case, typename... ArgTypes>
+CPP_concept InvocableWithCase =
+    CPP_requires_ref(is_invocable_with_case_, Func,
+                     std::integral_constant<decltype(Case), Case>, ArgTypes...);
+
 // A `constexpr` switch statement. Chooses the `MatchingCase` in `FirstCase,
 // Cases...` that is equal to `value` and then calls
 // `function.operator()<MatchingCase>(args...)`.
-template <auto FirstCase, std::same_as<decltype(FirstCase)> auto... Cases>
-auto ConstexprSwitch =
-    [](auto&& function,
-       const std::equality_comparable_with<decltype(FirstCase)> auto& value,
-       auto&&... args) -> decltype(auto) requires(requires {
-  AD_FWD(function).template operator()<FirstCase>(AD_FWD(args)...);
-} && (... &&
-      requires {
-        AD_FWD(function).template operator()<Cases>(AD_FWD(args)...);
-      })) {
-  if (value == FirstCase) {
-    return AD_FWD(function).template operator()<FirstCase>(AD_FWD(args)...);
-  } else if constexpr (sizeof...(Cases) > 0) {
-    return ConstexprSwitch<Cases...>(AD_FWD(function), value, AD_FWD(args)...);
-  } else {
-    AD_FAIL();
+template <auto FirstCase, auto... Cases>
+struct ConstexprSwitch {
+  CPP_template(typename FuncType, typename ValueType, typename... Args)(
+      requires((sizeof...(Cases) == 0) ||
+               ad_utility::SameAsAny<decltype(FirstCase), decltype(Cases)...>)
+          CPP_and std::equality_comparable_with<decltype(FirstCase),
+                                                decltype(FirstCase)>
+              CPP_and InvocableWithCase<FuncType, FirstCase, Args...>
+                  CPP_and(InvocableWithCase<FuncType, Cases,
+                                            Args...>&&...)) constexpr auto
+  operator()(FuncType&& function, const ValueType& value, Args&&... args) const
+      -> decltype(auto) {
+    if (value == FirstCase) {
+      return AD_FWD(function).template operator()<FirstCase>(AD_FWD(args)...);
+    } else if constexpr (sizeof...(Cases) > 0) {
+      return ConstexprSwitch<Cases...>{}(AD_FWD(function), value,
+                                         AD_FWD(args)...);
+    } else {
+      AD_FAIL();
+    }
   }
 };
 
@@ -166,9 +182,9 @@ auto toIntegerSequence() {
 // NumIntegers - 1 to an array of `NumIntegers` many integers that are each in
 // the range
 // `[0, ..., (maxValue)]`
-template <std::integral Int, size_t NumIntegers>
-constexpr std::array<Int, NumIntegers> integerToArray(Int value,
-                                                      Int numValues) {
+CPP_template(typename Int,
+             size_t NumIntegers)(requires std::integral<Int>) constexpr std::
+    array<Int, NumIntegers> integerToArray(Int value, Int numValues) {
   std::array<Int, NumIntegers> res;
   for (auto& el : res | ql::views::reverse) {
     el = value % numValues;
@@ -181,8 +197,9 @@ constexpr std::array<Int, NumIntegers> integerToArray(Int value,
 // the type of `Upper`) that contains each
 // value from `[0, ..., Upper - 1] ^ Num` exactly once. `^` denotes the
 // cartesian power.
-template <std::integral auto Upper, size_t Num>
-constexpr auto cartesianPowerAsArray() {
+CPP_template(auto Upper, size_t Num)(
+    requires std::integral<
+        decltype(Upper)>) constexpr auto cartesianPowerAsArray() {
   using Int = decltype(Upper);
   constexpr auto numValues = pow(Upper, Num);
   std::array<std::array<Int, Num>, numValues> arr;
@@ -196,8 +213,9 @@ constexpr auto cartesianPowerAsArray() {
 // value from `[0, ..., Upper - 1] X Num` exactly once. `X` denotes the
 // cartesian product of sets. The elements of the `integer_sequence` are
 // of type `std::array<Int, Num>` where `Int` is the type of `Upper`.
-template <std::integral auto Upper, size_t Num>
-auto cartesianPowerAsIntegerArray() {
+CPP_template(auto Upper,
+             size_t Num)(requires std::integral<
+                         decltype(Upper)>) auto cartesianPowerAsIntegerArray() {
   return toIntegerSequence<cartesianPowerAsArray<Upper, Num>()>();
 }
 
diff --git a/src/util/CopyableUniquePtr.h b/src/util/CopyableUniquePtr.h
index f3cc4cbe2f..bd64f95b9c 100644
--- a/src/util/CopyableUniquePtr.h
+++ b/src/util/CopyableUniquePtr.h
@@ -20,9 +20,9 @@ of the object for the `unique_ptr`.
 Currently not written with support for dynamically-allocated array of objects
 in mind, so that may not work.
 */
-template <typename T, typename Deleter = std::default_delete<T>>
-requires std::is_copy_constructible_v<T>
-class CopyableUniquePtr : public std::unique_ptr<T, Deleter> {
+CPP_template(typename T, typename Deleter = std::default_delete<T>)(
+    requires std::is_copy_constructible_v<T>) class CopyableUniquePtr
+    : public std::unique_ptr<T, Deleter> {
   // This makes calling functions, etc. from the base class so much easier.
   using Base = std::unique_ptr<T, Deleter>;
 
@@ -50,8 +50,9 @@ class CopyableUniquePtr : public std::unique_ptr<T, Deleter> {
   CopyableUniquePtr& operator=(CopyableUniquePtr&& ptr) = default;
 
   // Json serialization.
-  friend void to_json(OrderedOrUnorderedJson auto& j,
-                      const CopyableUniquePtr& p) {
+  CPP_template_2(typename S)(
+      requires OrderedOrUnorderedJson<
+          S>) friend void to_json(S& j, const CopyableUniquePtr& p) {
     /*
     The serialization of `CopyableUniquePtr` would have identical code to the
     serialization of a normal unique pointer, so we just re-cast it, to save on
diff --git a/src/util/DefaultValueSizeGetter.h b/src/util/DefaultValueSizeGetter.h
index 7573282bf3..a4e686149e 100644
--- a/src/util/DefaultValueSizeGetter.h
+++ b/src/util/DefaultValueSizeGetter.h
@@ -16,7 +16,6 @@ namespace ad_utility {
 
 // `ValueSizeGetter` for caches, which simply calls the `sizeof` operator.
 struct SizeOfSizeGetter {
-  template <typename T>
   /*
   If an object internally uses pointers, than `sizeof` doesn't return the actual
   size of the object.
@@ -27,15 +26,17 @@ struct SizeOfSizeGetter {
   than you will have to define custom move/copy constructor and assignment
   operators.
   */
-  requires std::is_trivially_copyable_v<T>
-  ad_utility::MemorySize operator()(const T& obj) const {
+  CPP_template(typename T)(requires std::is_trivially_copyable_v<T>)
+      ad_utility::MemorySize
+      operator()(const T& obj) const {
     return ad_utility::MemorySize::bytes(sizeof(obj));
   }
 };
 
 // `ValueSizeGetter` for instances of `std::basic_string`.
-template <ad_utility::isInstantiation<std::basic_string> StringType>
-struct StringSizeGetter {
+CPP_template(typename StringType)(
+    requires ad_utility::isInstantiation<
+        StringType, std::basic_string>) struct StringSizeGetter {
   ad_utility::MemorySize operator()(const StringType& str) const {
     return ad_utility::MemorySize::bytes(
         str.size() * sizeof(typename StringType::value_type));
diff --git a/src/util/Exception.h b/src/util/Exception.h
index 0f399084f8..dda5105c3e 100644
--- a/src/util/Exception.h
+++ b/src/util/Exception.h
@@ -11,6 +11,7 @@
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
+#include "backports/concepts.h"
 #include "util/SourceLocation.h"
 #include "util/TypeTraits.h"
 
@@ -85,19 +86,26 @@ class Exception : public std::exception {
 #define AD_FAIL() AD_THROW("This code should be unreachable")
 
 namespace ad_utility::detail {
+
+template <typename S>
+CPP_requires(is_str_catable_, requires(S&& s)(absl::StrCat(AD_FWD(s))));
+
+template <typename S>
+CPP_concept CanStrCat = CPP_requires_ref(is_str_catable_, S);
+
 // Helper functions that convert the various arguments to the
 // `AD_CONTRACT_CHECK` etc. macros to strings.
 // The argument must be
 // * A type that can be passed to `absl::StrCat` (e.g. `string`, `string_views`,
 // builtin numeric types) [first overload]
 // * A callbable that takes no arguments and returns a string [second overload]
-template <typename S>
-requires requires(S&& s) { absl::StrCat(AD_FWD(s)); }
-std::string getMessageImpl(S&& s) {
+CPP_template(typename S)(requires CanStrCat<S>) std::string
+    getMessageImpl(S&& s) {
   return absl::StrCat(AD_FWD(s));
 }
-std::string getMessageImpl(
-    ad_utility::InvocableWithConvertibleReturnType<std::string> auto&& f) {
+CPP_template(typename T)(
+    requires ad_utility::InvocableWithConvertibleReturnType<T, std::string>)
+    std::string getMessageImpl(T&& f) {
   return std::invoke(f);
 }
 
diff --git a/src/util/ExceptionHandling.h b/src/util/ExceptionHandling.h
index 812be307a7..54b0d5da8e 100644
--- a/src/util/ExceptionHandling.h
+++ b/src/util/ExceptionHandling.h
@@ -25,10 +25,11 @@ namespace detail {
 // propagate it. Can be used to make destructors `noexcept` when the destructor
 // has to perform actions that might throw, but when handling these exceptions
 // is not important.
-template <typename F>
-requires std::invocable<std::remove_cvref_t<F>>
-void ignoreExceptionIfThrows(F&& f,
-                             std::string_view additionalNote = "") noexcept {
+CPP_template(typename F)(
+    requires std::invocable<std::remove_cvref_t<
+        F>>) void ignoreExceptionIfThrows(F&& f,
+                                          std::string_view additionalNote =
+                                              "") noexcept {
   if constexpr (std::is_nothrow_invocable_v<std::remove_cvref_t<F>>) {
     std::invoke(AD_FWD(f));
     return;
@@ -52,14 +53,18 @@ void ignoreExceptionIfThrows(F&& f,
 // also is not easily recoverable. For an example usage see `PatternCreator.h`.
 // The actual termination call can be configured for testing purposes. Note that
 // this function must never throw an exception.
-template <typename F,
-          typename TerminateAction = decltype(detail::callStdTerminate)>
-requires(std::invocable<std::remove_cvref_t<F>> &&
-         std::is_nothrow_invocable_v<TerminateAction>)
-void terminateIfThrows(F&& f, std::string_view message,
-                       TerminateAction terminateAction = {},
-                       ad_utility::source_location l =
-                           ad_utility::source_location::current()) noexcept {
+CPP_template(typename F,
+             typename TerminateAction = decltype(detail::callStdTerminate))(
+    requires std::invocable<std::remove_cvref_t<F>> CPP_and
+        std::is_nothrow_invocable_v<
+            TerminateAction>) void terminateIfThrows(F&& f,
+                                                     std::string_view message,
+                                                     TerminateAction
+                                                         terminateAction = {},
+                                                     ad_utility::source_location
+                                                         l = ad_utility::
+                                                             source_location::
+                                                                 current()) noexcept {
   auto getErrorMessage =
       [&message, &l](const auto&... additionalMessages) -> std::string {
     return absl::StrCat(
@@ -112,10 +117,10 @@ class ThrowInDestructorIfSafe {
   int numExceptionsDuringConstruction_ = std::uncaught_exceptions();
 
  public:
-  void operator()(
-      std::invocable auto f,
-      std::convertible_to<std::string_view> auto const&... additionalMessages)
-      const {
+  CPP_template(typename FuncType,
+               typename... Args)(requires std::invocable<FuncType> CPP_and(
+      ...&& std::convertible_to<Args, std::string_view>)) void
+  operator()(FuncType f, const Args&... additionalMessages) const {
     auto logIgnoredException = [&additionalMessages...](std::string_view what) {
       std::string_view sep = sizeof...(additionalMessages) == 0 ? "" : " ";
       LOG(WARN) << absl::StrCat(
diff --git a/src/util/Generator.h b/src/util/Generator.h
index 604ba7e7c3..18bf0fc598 100644
--- a/src/util/Generator.h
+++ b/src/util/Generator.h
@@ -69,8 +69,8 @@ class generator_promise {
   }
 
   // Don't allow any use of 'co_await' inside the generator coroutine.
-  template <typename U>
-  std::suspend_never await_transform(U&& value) = delete;
+  CPP_template(typename U)(requires(!ad_utility::SimilarTo<GetDetails, U>))
+      std::suspend_never await_transform(U&& value) = delete;
 
   void rethrow_if_exception() const {
     if (m_exception) {
@@ -87,8 +87,9 @@ class generator_promise {
     Details& await_resume() noexcept { return promise_.details(); }
   };
 
-  DetailAwaiter await_transform(
-      [[maybe_unused]] ad_utility::SimilarTo<GetDetails> auto&& detail) {
+  CPP_template(typename DetailT)(
+      requires ad_utility::SimilarTo<GetDetails, DetailT>) DetailAwaiter
+      await_transform([[maybe_unused]] DetailT&& detail) {
     return {*this};
   }
 
diff --git a/src/util/Iterators.h b/src/util/Iterators.h
index 93ae1b51f4..00e1470ddb 100644
--- a/src/util/Iterators.h
+++ b/src/util/Iterators.h
@@ -23,6 +23,12 @@ inline auto accessViaBracketOperator = [](auto&& randomAccessContainer,
 
 using AccessViaBracketOperator = decltype(accessViaBracketOperator);
 
+template <typename A, typename P>
+CPP_requires(has_valid_accessor_, requires(A& a, P& p, uint64_t i)(&a(*p, i)));
+
+template <typename A, typename P>
+CPP_concept HasValidAccessor = CPP_requires_ref(has_valid_accessor_, A, P);
+
 /**
  * @brief Provide random access iterators for a random access container that
  * allows direct access to the `i-th` element in the structure.
@@ -68,16 +74,15 @@ class IteratorForAccessOperator {
   using RandomAccessContainerPtr =
       std::conditional_t<isConst, const RandomAccessContainer*,
                          RandomAccessContainer*>;
-  RandomAccessContainerPtr _vector = nullptr;
-  index_type _index{0};
-  Accessor _accessor{};
+  RandomAccessContainerPtr vector_ = nullptr;
+  index_type index_{0};
+  Accessor accessor_;
 
  public:
-  IteratorForAccessOperator() requires std::is_default_constructible_v<Accessor>
-  = default;
+  IteratorForAccessOperator() = default;
   IteratorForAccessOperator(RandomAccessContainerPtr vec, index_type index,
                             Accessor accessor = Accessor{})
-      : _vector{vec}, _index{index}, _accessor{std::move(accessor)} {}
+      : vector_{vec}, index_{index}, accessor_{std::move(accessor)} {}
 
   IteratorForAccessOperator(const IteratorForAccessOperator&) = default;
   IteratorForAccessOperator(IteratorForAccessOperator&&) noexcept = default;
@@ -87,14 +92,14 @@ class IteratorForAccessOperator {
       default;
 
   auto operator<=>(const IteratorForAccessOperator& rhs) const {
-    return (_index <=> rhs._index);
+    return (index_ <=> rhs.index_);
   }
   bool operator==(const IteratorForAccessOperator& rhs) const {
-    return _index == rhs._index;
+    return index_ == rhs.index_;
   }
 
   IteratorForAccessOperator& operator+=(difference_type n) {
-    _index += n;
+    index_ += n;
     return *this;
   }
   IteratorForAccessOperator operator+(difference_type n) const {
@@ -104,22 +109,22 @@ class IteratorForAccessOperator {
   }
 
   IteratorForAccessOperator& operator++() {
-    ++_index;
+    ++index_;
     return *this;
   }
   IteratorForAccessOperator operator++(int) & {
     IteratorForAccessOperator result{*this};
-    ++_index;
+    ++index_;
     return result;
   }
 
   IteratorForAccessOperator& operator--() {
-    --_index;
+    --index_;
     return *this;
   }
   IteratorForAccessOperator operator--(int) & {
     IteratorForAccessOperator result{*this};
-    --_index;
+    --index_;
     return result;
   }
 
@@ -129,7 +134,7 @@ class IteratorForAccessOperator {
   }
 
   IteratorForAccessOperator& operator-=(difference_type n) {
-    _index -= n;
+    index_ -= n;
     return *this;
   }
 
@@ -140,31 +145,29 @@ class IteratorForAccessOperator {
   }
 
   difference_type operator-(const IteratorForAccessOperator& rhs) const {
-    return static_cast<difference_type>(_index) -
-           static_cast<difference_type>(rhs._index);
+    return static_cast<difference_type>(index_) -
+           static_cast<difference_type>(rhs.index_);
   }
 
-  decltype(auto) operator*() const { return _accessor(*_vector, _index); }
-  decltype(auto) operator*() requires(!isConst) {
-    return _accessor(*_vector, _index);
+  decltype(auto) operator*() const { return accessor_(*vector_, index_); }
+  CPP_template(typename = void)(requires(!isConst)) decltype(auto) operator*() {
+    return accessor_(*vector_, index_);
   }
 
   // Only allowed, if `RandomAccessContainer` yields references and not values
-  template <typename A = Accessor, typename P = RandomAccessContainerPtr>
-  requires requires(A a, P p, uint64_t i) {
-    { &a(*p, i) };
-  } auto operator->() requires(!isConst) {
+  CPP_template(typename A = Accessor, typename P = RandomAccessContainerPtr)(
+      requires HasValidAccessor<A, P> CPP_and(!isConst)) auto
+  operator->() {
     return &(*(*this));
   }
-  template <typename A = Accessor, typename P = RandomAccessContainerPtr>
-  requires requires(A a, P p, uint64_t i) {
-    { &a(*p, i) };
-  } auto operator->() const {
+  CPP_template(typename A = Accessor, typename P = RandomAccessContainerPtr)(
+      requires HasValidAccessor<A, P>) auto
+  operator->() const {
     return &(*(*this));
   }
 
   decltype(auto) operator[](difference_type n) const {
-    return _accessor(*_vector, _index + n);
+    return accessor_(*vector_, index_ + n);
   }
 };
 
@@ -251,7 +254,7 @@ class InputRangeMixin {
     derived().start();
     return Iterator{this};
   }
-  Sentinel end() const { return {}; };
+  Sentinel end() const { return {}; }
 };
 
 // A similar mixin to the above, with slightly different characteristics:
@@ -378,19 +381,21 @@ class InputRangeTypeErased {
  public:
   // Constructor for ranges that directly inherit from
   // `InputRangeOptionalMixin`.
-  template <typename Range>
-  requires std::is_base_of_v<InputRangeFromGet<ValueType>, Range>
-  explicit InputRangeTypeErased(Range range)
+  CPP_template(typename Range)(
+      requires std::is_base_of_v<
+          InputRangeFromGet<ValueType>,
+          Range>) explicit InputRangeTypeErased(Range range)
       : impl_{std::make_unique<Range>(std::move(range))} {}
 
   // Constructor for all other ranges. We first pass them through the
   // `InputRangeToOptional` class from above to make it compatible with the base
   // class.
-  template <typename Range>
-  requires(!std::is_base_of_v<InputRangeFromGet<ValueType>, Range> &&
-           ql::ranges::range<Range> &&
-           std::same_as<ql::ranges::range_value_t<Range>, ValueType>)
-  explicit InputRangeTypeErased(Range range)
+  CPP_template(typename Range)(
+      requires CPP_NOT(std::is_base_of_v<InputRangeFromGet<ValueType>, Range>)
+          CPP_and ql::ranges::range<Range>
+              CPP_and std::same_as<
+                  ql::ranges::range_value_t<Range>,
+                  ValueType>) explicit InputRangeTypeErased(Range range)
       : impl_{std::make_unique<RangeToInputRangeFromGet<Range>>(
             std::move(range))} {}
 
diff --git a/src/util/JoinAlgorithms/FindUndefRanges.h b/src/util/JoinAlgorithms/FindUndefRanges.h
index 7b3f3296cb..5edd0b95b2 100644
--- a/src/util/JoinAlgorithms/FindUndefRanges.h
+++ b/src/util/JoinAlgorithms/FindUndefRanges.h
@@ -33,10 +33,11 @@ namespace ad_utility {
 // is the number of matching elements.
 // TODO<joka921> This can be optimized when we also know which columns of
 // `[begin, end)` can possibly contain UNDEF values.
-template <std::random_access_iterator It>
-auto findSmallerUndefRangesForRowsWithoutUndef(
-    const auto& row, It begin, It end,
-    [[maybe_unused]] bool& resultMightBeUnsorted) -> cppcoro::generator<It> {
+CPP_template(typename It)(requires std::random_access_iterator<It>)  //
+    auto findSmallerUndefRangesForRowsWithoutUndef(
+        const auto& row, It begin, It end,
+        [[maybe_unused]] bool& resultMightBeUnsorted)
+        -> cppcoro::generator<It> {
   using Row = typename std::iterator_traits<It>::value_type;
   assert(row.size() == (*begin).size());
   assert(
@@ -71,10 +72,10 @@ auto findSmallerUndefRangesForRowsWithoutUndef(
 
 // TODO<joka921> We could also implement a version that is optimized on the
 // [begin, end] range not having UNDEF values in some of the columns
-template <std::random_access_iterator It>
-auto findSmallerUndefRangesForRowsWithUndefInLastColumns(
-    const auto& row, const size_t numLastUndefined, It begin, It end,
-    bool& resultMightBeUnsorted) -> cppcoro::generator<It> {
+CPP_template(typename It)(requires std::random_access_iterator<It>)  //
+    auto findSmallerUndefRangesForRowsWithUndefInLastColumns(
+        const auto& row, const size_t numLastUndefined, It begin, It end,
+        bool& resultMightBeUnsorted) -> cppcoro::generator<It> {
   using Row = typename std::iterator_traits<It>::value_type;
   const size_t numJoinColumns = row.size();
   assert(row.size() == (*begin).size());
@@ -121,10 +122,10 @@ auto findSmallerUndefRangesForRowsWithUndefInLastColumns(
 
 // This function has no additional preconditions, but runs in `O((end - begin) *
 // numColumns)`.
-template <std::random_access_iterator It>
-auto findSmallerUndefRangesArbitrary(const auto& row, It begin, It end,
-                                     bool& resultMightBeUnsorted)
-    -> cppcoro::generator<It> {
+CPP_template(typename It)(requires std::random_access_iterator<It>)  //
+    auto findSmallerUndefRangesArbitrary(const auto& row, It begin, It end,
+                                         bool& resultMightBeUnsorted)
+        -> cppcoro::generator<It> {
   assert(row.size() == (*begin).size());
   assert(
       ql::ranges::is_sorted(begin, end, ql::ranges::lexicographical_compare));
@@ -165,9 +166,10 @@ auto findSmallerUndefRangesArbitrary(const auto& row, It begin, It end,
 // have additional information about the input (most notably which of the join
 // columns contain no UNDEF at all) and therefore a more specialized routine
 // should be chosen.
-template <std::random_access_iterator It>
-auto findSmallerUndefRanges(const auto& row, It begin, It end,
-                            bool& resultMightBeUnsorted)
+CPP_template(typename It)(
+    requires std::random_access_iterator<
+        It>) auto findSmallerUndefRanges(const auto& row, It begin, It end,
+                                         bool& resultMightBeUnsorted)
     -> cppcoro::generator<It> {
   size_t numLastUndefined = 0;
   assert(row.size() > 0);
diff --git a/src/util/LambdaHelpers.h b/src/util/LambdaHelpers.h
index 5ba66a0993..764d80747b 100644
--- a/src/util/LambdaHelpers.h
+++ b/src/util/LambdaHelpers.h
@@ -6,22 +6,28 @@
 #define QLEVER_LAMBDAHELPERS_H
 
 #include "./Forward.h"
+#include "backports/concepts.h"
 
 namespace ad_utility {
 
 namespace detail {
 // Helper type for `makeAssignableLambda`.
+template <typename Lambda, bool Movable, bool Copyable>
+struct AssignableLambdaImpl;
+
 template <typename Lambda>
-struct AssignableLambdaImpl {
+struct AssignableLambdaImpl<Lambda, false, false> {
  private:
   Lambda _lambda;
 
+ protected:
+  Lambda& lambda() { return _lambda; }
+  const Lambda& lambda() const { return _lambda; }
+
  public:
   explicit constexpr AssignableLambdaImpl(Lambda lambda)
       : _lambda{std::move(lambda)} {}
-  constexpr AssignableLambdaImpl()
-      requires std::is_default_constructible_v<Lambda>
-      = default;
+  AssignableLambdaImpl() = default;
 
   decltype(auto) operator()(auto&&... args) noexcept(
       noexcept(_lambda(AD_FWD(args)...))) {
@@ -32,21 +38,53 @@ struct AssignableLambdaImpl {
       noexcept(noexcept(_lambda(AD_FWD(args)...))) {
     return _lambda(AD_FWD(args)...);
   }
+};
 
-  AssignableLambdaImpl& operator=(const AssignableLambdaImpl& other)
-      requires std::is_copy_constructible_v<Lambda> {
-    std::destroy_at(&_lambda);
-    std::construct_at(&_lambda, other._lambda);
+template <typename Lambda>
+struct AssignableLambdaImpl<Lambda, true, false>
+    : public AssignableLambdaImpl<Lambda, false, false> {
+ private:
+  using Base = AssignableLambdaImpl<Lambda, false, false>;
+
+ public:
+  using Base::Base;
+  using Base::operator();
+
+ protected:
+  using Base::lambda;
+
+ public:
+  AssignableLambdaImpl& operator=(AssignableLambdaImpl&& other) noexcept
+      QL_CONCEPT_OR_NOTHING(requires std::is_move_constructible_v<Lambda>) {
+    std::destroy_at(&lambda());
+    std::construct_at(&lambda(), std::move(other.lambda()));
     return *this;
   }
 
-  AssignableLambdaImpl& operator=(AssignableLambdaImpl&& other) noexcept
-      requires std::is_move_constructible_v<Lambda> {
-    std::destroy_at(&_lambda);
-    std::construct_at(&_lambda, std::move(other._lambda));
+  AssignableLambdaImpl(const AssignableLambdaImpl&) = default;
+  AssignableLambdaImpl(AssignableLambdaImpl&&) noexcept = default;
+};
+
+template <typename Lambda>
+struct AssignableLambdaImpl<Lambda, true, true>
+    : private AssignableLambdaImpl<Lambda, true, false> {
+ private:
+  using Base = AssignableLambdaImpl<Lambda, true, false>;
+  using Base::lambda;
+
+ public:
+  using Base::Base;
+  using Base::operator();
+
+  AssignableLambdaImpl& operator=(const AssignableLambdaImpl& other)
+      QL_CONCEPT_OR_NOTHING(requires std::is_copy_constructible_v<Lambda>) {
+    std::destroy_at(&lambda());
+    std::construct_at(&lambda(), other.lambda());
     return *this;
   }
 
+  AssignableLambdaImpl& operator=(AssignableLambdaImpl&& other) = default;
+
   AssignableLambdaImpl(const AssignableLambdaImpl&) = default;
   AssignableLambdaImpl(AssignableLambdaImpl&&) noexcept = default;
 };
@@ -59,8 +97,12 @@ struct AssignableLambdaImpl {
 /// iterator types that store lambda expressions (see Iterators.h), because many
 /// STL algorithms require iterators to be assignable. The assignment operators
 /// are implemented using `destroy_at` and `construct_at`.
-constexpr auto makeAssignableLambda(auto lambda) {
-  return detail::AssignableLambdaImpl{std::move(lambda)};
+template <typename Lambda>
+constexpr auto makeAssignableLambda(Lambda lambda) {
+  return detail::AssignableLambdaImpl<Lambda,
+                                      std::is_move_constructible_v<Lambda>,
+                                      std::is_copy_constructible_v<Lambda>>{
+      std::move(lambda)};
 }
 }  // namespace ad_utility
 
diff --git a/src/util/MemorySize/MemorySize.h b/src/util/MemorySize/MemorySize.h
index 92e2f01465..da8feaaaae 100644
--- a/src/util/MemorySize/MemorySize.h
+++ b/src/util/MemorySize/MemorySize.h
@@ -29,8 +29,9 @@ namespace ad_utility {
 */
 
 // A concept, for when a type should be an integral, or a floating point.
+// TODO<joka921, gpicciuca> Turn back to  `CPP_concept`
 template <typename T>
-concept Arithmetic = std::integral<T> || std::floating_point<T>;
+concept Arithmetic = (std::integral<T> || std::floating_point<T>);
 
 /*
 An abstract class, that represents an amount of memory.
@@ -69,12 +70,16 @@ class MemorySize {
   memory size saved internally. Always requires the exact memory size unit and
   size wanted.
   */
-  template <std::integral T>
-  constexpr static MemorySize bytes(T numBytes);
-  constexpr static MemorySize kilobytes(Arithmetic auto numKilobytes);
-  constexpr static MemorySize megabytes(Arithmetic auto numMegabytes);
-  constexpr static MemorySize gigabytes(Arithmetic auto numGigabytes);
-  constexpr static MemorySize terabytes(Arithmetic auto numTerabytes);
+  CPP_template(typename T)(requires std::integral<T>)  //
+      constexpr static MemorySize bytes(T numBytes);
+  CPP_template(typename T)(requires Arithmetic<T>)  //
+      constexpr static MemorySize kilobytes(T numKilobytes);
+  CPP_template(typename T)(requires Arithmetic<T>)  //
+      constexpr static MemorySize megabytes(T numMegabytes);
+  CPP_template(typename T)(requires Arithmetic<T>)  //
+      constexpr static MemorySize gigabytes(T numGigabytes);
+  CPP_template(typename T)(requires Arithmetic<T>)  //
+      constexpr static MemorySize terabytes(T numTerabytes);
 
   // Factory for max size instance.
   constexpr static MemorySize max();
@@ -119,20 +124,23 @@ class MemorySize {
   constexpr MemorySize operator-(const MemorySize& m) const;
   constexpr MemorySize& operator-=(const MemorySize& m);
 
-  template <Arithmetic T>
-  constexpr MemorySize operator*(const T c) const;
+  CPP_template(typename T)(requires Arithmetic<T>)  //
+      constexpr MemorySize
+      operator*(const T c) const;
 
-  template <Arithmetic T>
-  friend constexpr MemorySize operator*(const T c, const MemorySize m);
+  template <typename T>
+  friend constexpr auto operator*(const T c, const MemorySize m)
+      -> CPP_ret(MemorySize)(requires Arithmetic<T>);
 
-  template <Arithmetic T>
-  constexpr MemorySize& operator*=(const T c);
+  CPP_template(typename T)(requires Arithmetic<T>)  //
+      constexpr MemorySize&
+      operator*=(const T c);
 
-  template <Arithmetic T>
-  constexpr MemorySize operator/(const T c) const;
+  CPP_template(typename T)(requires Arithmetic<T>) constexpr MemorySize
+  operator/(const T c) const;
 
-  template <Arithmetic T>
-  constexpr MemorySize& operator/=(const T c);
+  CPP_template(typename T)(requires Arithmetic<T>) constexpr MemorySize&
+  operator/=(const T c);
 
  private:
   // Constructor for the factory functions.
@@ -198,8 +206,8 @@ constexpr ConstexprMap<std::string_view, double, 5> maxAmountOfUnit(
      std::pair{"TB", sizeTDivision(size_t_max, numBytesPerUnit.at("TB"))}});
 
 // Converts a given number to `size_t`. Rounds up, if needed.
-template <Arithmetic T>
-constexpr size_t ceilAndCastToSizeT(const T d) {
+CPP_template(typename T)(requires Arithmetic<T>) constexpr size_t
+    ceilAndCastToSizeT(const T d) {
   if constexpr (std::is_floating_point_v<T>) {
     // TODO<c++23> As of `c++23`, `std::ceil` is constexpr and can be used.
     const auto unrounded = static_cast<size_t>(d);
@@ -218,9 +226,9 @@ constexpr size_t ceilAndCastToSizeT(const T d) {
 
 @return The amount of bytes. Rounded up, if needed.
 */
-template <Arithmetic T>
-constexpr size_t convertMemoryUnitsToBytes(const T amountOfUnits,
-                                           std::string_view unitName) {
+CPP_template(typename T)(requires Arithmetic<T>)  //
+    constexpr size_t convertMemoryUnitsToBytes(const T amountOfUnits,
+                                               std::string_view unitName) {
   if constexpr (std::is_signed_v<T>) {
     // Negative values makes no sense.
     AD_CONTRACT_CHECK(amountOfUnits >= 0);
@@ -269,11 +277,11 @@ multiplied/divied with.
 `double.` Note, that the rounding and casting to `size_t` for floating point
 return types will be automatically done, and can be ignored by `func`.
  */
-template <Arithmetic T, typename Func>
-requires std::invocable<Func, const double, const double> ||
-         std::invocable<Func, const size_t, const size_t>
-constexpr MemorySize magicImplForDivAndMul(const MemorySize& m, const T c,
-                                           Func func) {
+CPP_template(typename T, typename Func)(requires Arithmetic<T> CPP_and(
+    std::invocable<Func, const double, const double> ||
+    std::invocable<Func, const size_t, const size_t>))               //
+    constexpr MemorySize magicImplForDivAndMul(const MemorySize& m,  //
+                                               const T c, Func func) {
   // In order for the results to be as precise as possible, we cast to highest
   // precision data type variant of `T`.
   using PrecisionType =
@@ -286,8 +294,8 @@ constexpr MemorySize magicImplForDivAndMul(const MemorySize& m, const T c,
 }  // namespace detail
 
 // _____________________________________________________________________________
-template <std::integral T>
-constexpr MemorySize MemorySize::bytes(T numBytes) {
+CPP_template_def(typename T)(requires std::integral<T>) constexpr MemorySize
+    MemorySize::bytes(T numBytes) {
   if constexpr (std::is_signed_v<T>) {
     // Doesn't make much sense to a negative amount of memory.
     AD_CONTRACT_CHECK(numBytes >= 0);
@@ -297,22 +305,26 @@ constexpr MemorySize MemorySize::bytes(T numBytes) {
 }
 
 // _____________________________________________________________________________
-constexpr MemorySize MemorySize::kilobytes(Arithmetic auto numKilobytes) {
+CPP_template_def(typename T)(requires Arithmetic<T>) constexpr MemorySize
+    MemorySize::kilobytes(T numKilobytes) {
   return MemorySize{detail::convertMemoryUnitsToBytes(numKilobytes, "kB")};
 }
 
 // _____________________________________________________________________________
-constexpr MemorySize MemorySize::megabytes(Arithmetic auto numMegabytes) {
+CPP_template_def(typename T)(requires Arithmetic<T>) constexpr MemorySize
+    MemorySize::megabytes(T numMegabytes) {
   return MemorySize{detail::convertMemoryUnitsToBytes(numMegabytes, "MB")};
 }
 
 // _____________________________________________________________________________
-constexpr MemorySize MemorySize::gigabytes(Arithmetic auto numGigabytes) {
+CPP_template_def(typename T)(requires Arithmetic<T>) constexpr MemorySize
+    MemorySize::gigabytes(T numGigabytes) {
   return MemorySize{detail::convertMemoryUnitsToBytes(numGigabytes, "GB")};
 }
 
 // _____________________________________________________________________________
-constexpr MemorySize MemorySize::terabytes(Arithmetic auto numTerabytes) {
+CPP_template_def(typename T)(requires Arithmetic<T>) constexpr MemorySize
+    MemorySize::terabytes(T numTerabytes) {
   return MemorySize{detail::convertMemoryUnitsToBytes(numTerabytes, "TB")};
 }
 
@@ -384,8 +396,8 @@ constexpr MemorySize& MemorySize::operator-=(const MemorySize& m) {
 }
 
 // _____________________________________________________________________________
-template <Arithmetic T>
-constexpr MemorySize MemorySize::operator*(const T c) const {
+CPP_template_def(typename T)(requires Arithmetic<T>) constexpr MemorySize
+    MemorySize::operator*(const T c) const {
   if constexpr (std::is_signed_v<T>) {
     // A negative amount of memory wouldn't make much sense.
     AD_CONTRACT_CHECK(c >= static_cast<T>(0));
@@ -403,21 +415,23 @@ constexpr MemorySize MemorySize::operator*(const T c) const {
 }
 
 // _____________________________________________________________________________
-template <Arithmetic T>
-constexpr MemorySize operator*(const T c, const MemorySize m) {
+template <typename T>
+constexpr auto operator*(const T c, const MemorySize m)
+    -> CPP_ret(MemorySize)(requires Arithmetic<T>) {
   return m * c;
 }
 
 // _____________________________________________________________________________
-template <Arithmetic T>
-constexpr MemorySize& MemorySize::operator*=(const T c) {
+CPP_template_def(typename T)(
+    requires Arithmetic<
+        T>) constexpr MemorySize& MemorySize::operator*=(const T c) {
   *this = *this * c;
   return *this;
 }
 
 // _____________________________________________________________________________
-template <Arithmetic T>
-constexpr MemorySize MemorySize::operator/(const T c) const {
+CPP_template_def(typename T)(requires Arithmetic<T>) constexpr MemorySize
+    MemorySize::operator/(const T c) const {
   if constexpr (std::is_signed_v<T>) {
     // A negative amount of memory wouldn't make much sense.
     AD_CONTRACT_CHECK(c > static_cast<T>(0));
@@ -460,8 +474,9 @@ constexpr MemorySize MemorySize::operator/(const T c) const {
 }
 
 // _____________________________________________________________________________
-template <Arithmetic T>
-constexpr MemorySize& MemorySize::operator/=(const T c) {
+CPP_template_def(typename T)(
+    requires Arithmetic<
+        T>) constexpr MemorySize& MemorySize::operator/=(const T c) {
   *this = *this / c;
   return *this;
 }
diff --git a/src/util/MmapVector.h b/src/util/MmapVector.h
index 447f219834..cc2ed42f00 100644
--- a/src/util/MmapVector.h
+++ b/src/util/MmapVector.h
@@ -154,9 +154,10 @@ class MmapVector {
   MmapVector(MmapVector<T>&& other) noexcept;
   MmapVector& operator=(MmapVector<T>&& other) noexcept;
 
-  template <class Arg, typename... Args>
-  requires(!std::derived_from<std::remove_cvref_t<Arg>, MmapVector<T>>)
-  MmapVector(Arg&& arg, Args&&... args) : MmapVector<T>() {
+  CPP_template(class Arg, typename... Args)(requires CPP_NOT(
+      std::derived_from<std::remove_cvref_t<Arg>, MmapVector<T>>))
+      MmapVector(Arg&& arg, Args&&... args)
+      : MmapVector<T>() {
     this->open(AD_FWD(arg), AD_FWD(args)...);
   }
 
@@ -311,9 +312,10 @@ class MmapVectorView : private MmapVector<T> {
 
   // construct with any combination of arguments that is supported by the open()
   // member function
-  template <typename Arg, typename... Args>
-  requires(!std::same_as<std::remove_cvref_t<Arg>, MmapVectorView>)
-  explicit MmapVectorView(Arg&& arg, Args&&... args) {
+  CPP_template(typename Arg, typename... Args)(requires CPP_NOT(
+      std::same_as<std::remove_cvref_t<Arg>,
+                   MmapVectorView>)) explicit MmapVectorView(Arg&& arg,
+                                                             Args&&... args) {
     open(AD_FWD(arg), AD_FWD(args)...);
   }
 
@@ -373,9 +375,11 @@ class MmapVectorTmp : public MmapVector<T> {
       : MmapVector<T>(std::move(rhs)) {}
   MmapVectorTmp(const MmapVectorTmp<T>& rhs) = delete;
 
-  template <class Arg, typename... Args>
-  requires(!std::derived_from<std::remove_cvref_t<Arg>, MmapVectorTmp>)
-  explicit MmapVectorTmp(Arg&& arg, Args&&... args) : MmapVector<T>() {
+  CPP_template(class Arg, typename... Args)(requires CPP_NOT(
+      std::derived_from<std::remove_cvref_t<Arg>,
+                        MmapVectorTmp>)) explicit MmapVectorTmp(Arg&& arg,
+                                                                Args&&... args)
+      : MmapVector<T>() {
     this->open(AD_FWD(arg), AD_FWD(args)...);
   }
 
diff --git a/src/util/NBitInteger.h b/src/util/NBitInteger.h
index 18f32d84a7..a222013b7c 100644
--- a/src/util/NBitInteger.h
+++ b/src/util/NBitInteger.h
@@ -10,8 +10,8 @@
 namespace ad_utility {
 
 // A type for signed integers that only need `N` bits to represent.
-template <uint8_t N>
-requires(N <= 64 && N >= 1) class NBitInteger {
+CPP_template(uint8_t N)(requires(N <= 64) CPP_and(N >= 1))  //
+    class NBitInteger {
   using T = uint64_t;
   static constexpr uint8_t UNUSED_BITS = 64 - N;
 
diff --git a/src/util/OnDestructionDontThrowDuringStackUnwinding.h b/src/util/OnDestructionDontThrowDuringStackUnwinding.h
index 1d5fa9b684..4ccf2ba0e1 100644
--- a/src/util/OnDestructionDontThrowDuringStackUnwinding.h
+++ b/src/util/OnDestructionDontThrowDuringStackUnwinding.h
@@ -10,9 +10,8 @@ namespace detail {
 
 // The implementation of `makeOnDestructionDontThrowDuringStackUnwinding` (see
 // below).
-template <typename F>
-requires(std::is_invocable_v<F>)
-class OnDestructionDontThrowDuringStackUnwinding {
+CPP_template(typename F)(requires std::is_invocable_v<
+                         F>) class OnDestructionDontThrowDuringStackUnwinding {
   static_assert(
       !std::is_nothrow_invocable_v<F>,
       "When using a non-throwing callback, use the simpler `absl::Cleanup`");
@@ -72,9 +71,9 @@ class OnDestructionCreator {
 // return object in a container because all of its constructors are either
 // private or deleted. This is disabled deliberately as it might lead to program
 // termination (for `std::vector`) or to uncalled destructors.
-template <std::invocable F>
-[[nodiscard("")]] detail::OnDestructionDontThrowDuringStackUnwinding<F>
-makeOnDestructionDontThrowDuringStackUnwinding(F f) {
+CPP_template(typename F)(requires std::invocable<F>)
+    [[nodiscard("")]] detail::OnDestructionDontThrowDuringStackUnwinding<
+        F> makeOnDestructionDontThrowDuringStackUnwinding(F f) {
   static_assert(
       !std::is_nothrow_invocable_v<F>,
       "When using a non-throwing callback, use the simpler `absl::Cleanup`");
diff --git a/src/util/ParallelMultiwayMerge.h b/src/util/ParallelMultiwayMerge.h
index fa17cd57a8..13b15735b3 100644
--- a/src/util/ParallelMultiwayMerge.h
+++ b/src/util/ParallelMultiwayMerge.h
@@ -21,8 +21,8 @@ using namespace ad_utility::memory_literals;
 // moved. It is necessary to explicitly pass the type `T` stored in the vector
 // to enable the usage of this lambda in combination with `std::bind_front` and
 // `std::ref`.
-template <bool moveElements, typename T, ValueSizeGetter<T> SizeGetter>
-constexpr auto pushSingleElement =
+CPP_template(bool moveElements, typename T, typename SizeGetter)(
+    requires ValueSizeGetter<SizeGetter, T>) constexpr auto pushSingleElement =
     [](std::vector<T>& buffer, MemorySize& sz, auto& el) {
       sz += SizeGetter{}(el);
       if constexpr (moveElements) {
@@ -35,13 +35,13 @@ constexpr auto pushSingleElement =
 // This concept is fulfilled if `Range` is a range that stores values of type
 // `T`.
 template <typename Range, typename T>
-concept RangeWithValue = ql::ranges::range<Range> &&
-                         std::same_as<ql::ranges::range_value_t<Range>, T>;
+CPP_concept RangeWithValue = ql::ranges::range<Range> &&
+                             std::same_as<ql::ranges::range_value_t<Range>, T>;
 
 // Fulfilled if `Range` is a random access range the elements of which are
 // ranges of elements of type `T`, e.g. `std::vector<std::generator<T>>`.
 template <typename Range, typename T>
-concept RandomAccessRangeOfRanges =
+CPP_concept RandomAccessRangeOfRanges =
     ql::ranges::random_access_range<Range> &&
     RangeWithValue<ql::ranges::range_value_t<Range>, T>;
 
@@ -51,12 +51,15 @@ concept RandomAccessRangeOfRanges =
 // ranges will be moved.
 // TODO<joka921> Maybe add a `buffering generator` that automatically stores the
 // buffers.
-template <typename T, bool moveElements, ValueSizeGetter<T> SizeGetter>
-cppcoro::generator<std::vector<T>> lazyBinaryMerge(
-    MemorySize maxMem, size_t maxBlockSize, RangeWithValue<T> auto range1,
-    RangeWithValue<T> auto range2,
-    ad_utility::InvocableWithExactReturnType<bool, const T&, const T&> auto
-        comparison) {
+CPP_template(typename T, bool moveElements, typename SizeGetter,
+             typename Range1, typename Range2, typename ComparisonFuncT)(
+    requires ValueSizeGetter<SizeGetter, T> CPP_and RangeWithValue<Range1, T>
+        CPP_and RangeWithValue<Range2, T>
+            CPP_and ad_utility::InvocableWithExactReturnType<
+                ComparisonFuncT, bool, const T&, const T&>)
+    cppcoro::generator<std::vector<T>> lazyBinaryMerge(
+        MemorySize maxMem, size_t maxBlockSize, Range1 range1, Range2 range2,
+        ComparisonFuncT comparison) {
   // Set up the buffer as well as a lambda to clear and reserve it.
   std::vector<T> buffer;
   MemorySize sizeOfCurrentBlock{};
@@ -148,10 +151,11 @@ cppcoro::generator<std::vector<T>> lazyBinaryMerge(
 
 // Yield the elements of the `range` in blocks of the given `blocksize`.
 // TODO<joka921> This gets much simpler with the buffering generator.
-template <typename T, bool moveElements, ValueSizeGetter<T> SizeGetter>
-cppcoro::generator<std::vector<T>> batchToVector(MemorySize maxMem,
-                                                 size_t blocksize,
-                                                 RangeWithValue<T> auto range) {
+CPP_template(typename T, bool moveElements, typename SizeGetter, typename R)(
+    requires ValueSizeGetter<SizeGetter, T> CPP_and RangeWithValue<R, T>)
+    cppcoro::generator<std::vector<T>> batchToVector(MemorySize maxMem,
+                                                     size_t blocksize,
+                                                     R range) {
   std::vector<T> buffer;
   buffer.reserve(blocksize);
   MemorySize curMem = 0_B;
@@ -172,12 +176,15 @@ cppcoro::generator<std::vector<T>> batchToVector(MemorySize maxMem,
 // The recursive implementation of `parallelMultiwayMerge` (see below). The
 // difference is, that the memory limit in this function is per node in the
 // recursion tree.
-template <typename T, bool moveElements,
-          ValueSizeGetter<T> SizeGetter = DefaultValueSizeGetter<T>>
-cppcoro::generator<std::vector<T>> parallelMultiwayMergeImpl(
-    MemorySize maxMemPerNode, size_t blocksize,
-    detail::RandomAccessRangeOfRanges<T> auto&& rangeOfRanges,
-    InvocableWithExactReturnType<bool, const T&, const T&> auto comparison) {
+CPP_template(typename T, bool moveElements, typename SizeGetter, typename R,
+             typename ComparisonFuncT)(
+    requires detail::RandomAccessRangeOfRanges<R, T> CPP_and
+        ValueSizeGetter<SizeGetter, T>
+            CPP_and InvocableWithExactReturnType<ComparisonFuncT, bool,
+                                                 const T&, const T&>)
+    cppcoro::generator<std::vector<T>> parallelMultiwayMergeImpl(
+        MemorySize maxMemPerNode, size_t blocksize, R&& rangeOfRanges,
+        ComparisonFuncT comparison) {
   AD_CORRECTNESS_CHECK(!rangeOfRanges.empty());
   auto moveIf = [](auto& range) -> decltype(auto) {
     if constexpr (moveElements) {
@@ -205,14 +212,18 @@ cppcoro::generator<std::vector<T>> parallelMultiwayMergeImpl(
 
     auto parallelMerge = [join, blocksize, comparison, maxMemPerNode](
                              auto it, auto end) {
+      auto subRange{ql::ranges::subrange{it, end}};
       return join(parallelMultiwayMergeImpl<T, moveElements, SizeGetter>(
-          maxMemPerNode, blocksize, ql::ranges::subrange{it, end}, comparison));
+          maxMemPerNode, blocksize, std::move(subRange), comparison));
     };
 
+    auto mergeRange1 = parallelMerge(beg, splitIt);
+    auto mergeRange2 = parallelMerge(splitIt, end);
+
     return ad_utility::streams::runStreamAsync(
         detail::lazyBinaryMerge<T, moveElements, SizeGetter>(
-            maxMemPerNode, blocksize, parallelMerge(beg, splitIt),
-            parallelMerge(splitIt, end), comparison),
+            maxMemPerNode, blocksize, std::move(mergeRange1),
+            std::move(mergeRange2), comparison),
         2);
   }
 }
@@ -223,19 +234,30 @@ cppcoro::generator<std::vector<T>> parallelMultiwayMergeImpl(
 // used in addition to limit the size of intermediate blocks in the recursive
 // implementation. It can be tweaked for maximum performance, currently values
 // of at least `50-100` seem to work well.
+CPP_template(typename T, bool moveElements,
+             typename SizeGetter)(requires ValueSizeGetter<SizeGetter,
+                                                           T>)  //
+    struct ParallelMultiwayMergeStruct {
+  CPP_template_2(typename R, typename Comp)(
+      requires detail::RandomAccessRangeOfRanges<R, T> CPP_and
+          ValueSizeGetter<SizeGetter, T>
+              CPP_and
+                  InvocableWithExactReturnType<Comp, bool, const T&, const T&>)
+      cppcoro::generator<std::vector<T>>
+      operator()(MemorySize memoryLimit, R&& rangeOfRanges, Comp comparison,
+                 size_t blocksize = 100) const {
+    // There is one suboperation per input in the recursion tree, so we have to
+    // divide the memory limit.
+    auto maxMemPerNode = memoryLimit / ql::ranges::size(rangeOfRanges);
+    return detail::parallelMultiwayMergeImpl<T, moveElements, SizeGetter>(
+        maxMemPerNode, blocksize, AD_FWD(rangeOfRanges), std::move(comparison));
+  }
+};
+// A variable, s.t. we don't have to initiate a struct each time.
 template <typename T, bool moveElements,
-          ValueSizeGetter<T> SizeGetter = DefaultValueSizeGetter<T>>
-cppcoro::generator<std::vector<T>> parallelMultiwayMerge(
-    MemorySize memoryLimit,
-    detail::RandomAccessRangeOfRanges<T> auto&& rangeOfRanges,
-    InvocableWithExactReturnType<bool, const T&, const T&> auto comparison,
-    size_t blocksize = 100) {
-  // There is one suboperation per input in the recursion tree, so we have to
-  // divide the memory limit.
-  auto maxMemPerNode = memoryLimit / ql::ranges::size(rangeOfRanges);
-  return detail::parallelMultiwayMergeImpl<T, moveElements, SizeGetter>(
-      maxMemPerNode, blocksize, AD_FWD(rangeOfRanges), std::move(comparison));
-}
+          typename SizeGetter = DefaultValueSizeGetter<T>>
+constexpr ParallelMultiwayMergeStruct<T, moveElements, SizeGetter>
+    parallelMultiwayMerge;
 }  // namespace ad_utility
 
 #endif  // QLEVER_PARALLELMULTIWAYMERGE_H
diff --git a/src/util/Parameters.h b/src/util/Parameters.h
index ea04a59609..7cedd1746f 100644
--- a/src/util/Parameters.h
+++ b/src/util/Parameters.h
@@ -36,12 +36,12 @@ struct ParameterBase {
 
 // Concepts for the template types of `Parameter`.
 template <typename FunctionType, typename ToType>
-concept ParameterFromStringType =
+CPP_concept ParameterFromStringType =
     std::default_initializable<FunctionType> &&
     InvocableWithSimilarReturnType<FunctionType, ToType, const std::string&>;
 
 template <typename FunctionType, typename FromType>
-concept ParameterToStringType =
+CPP_concept ParameterToStringType =
     std::default_initializable<FunctionType> &&
     InvocableWithSimilarReturnType<FunctionType, std::string, FromType>;
 
@@ -54,9 +54,12 @@ concept ParameterToStringType =
 ///         a std::string representation.
 /// \tparam Name The Name of the parameter (there are typically a lot of
 ///         parameters with the same `Type`).
-template <std::semiregular Type, ParameterFromStringType<Type> FromString,
-          ParameterToStringType<Type> ToString, ParameterName Name>
-struct Parameter : public ParameterBase {
+CPP_template(typename Type, typename FromString, typename ToString,
+             ParameterName Name)(
+    requires std::semiregular<Type> CPP_and
+        ParameterFromStringType<FromString, Type>
+            CPP_and ParameterToStringType<ToString, Type>) struct Parameter
+    : public ParameterBase {
   constexpr static ParameterName name = Name;
 
  private:
@@ -132,14 +135,14 @@ namespace detail::parameterConceptImpl {
 template <typename T>
 struct ParameterConceptImpl : std::false_type {};
 
-template <std::semiregular Type, ParameterFromStringType<Type> FromString,
-          ParameterToStringType<Type> ToString, ParameterName Name>
+template <typename Type, typename FromString, typename ToString,
+          ParameterName Name>
 struct ParameterConceptImpl<Parameter<Type, FromString, ToString, Name>>
     : std::true_type {};
 }  // namespace detail::parameterConceptImpl
 
 template <typename T>
-concept IsParameter =
+CPP_concept IsParameter =
     detail::parameterConceptImpl::ParameterConceptImpl<T>::value;
 
 namespace detail::parameterShortNames {
@@ -232,8 +235,12 @@ using DurationParameter = Parameter<ad_utility::ParseableDuration<DurationType>,
 /// "increase the cache size by 20%") nor an atomic update of multiple
 /// parameters at the same time. If needed, this functionality could be added
 /// to the current implementation.
-template <IsParameter... ParameterTypes>
+template <QL_CONCEPT_OR_TYPENAME(IsParameter)... ParameterTypes>
 class Parameters {
+  // In C++17 mode we cannot use SFINAE, but we also currently don't need it,
+  // add a static_assert for safety should this ever change.
+  static_assert((... && IsParameter<ParameterTypes>));
+
  private:
   using Tuple = std::tuple<ad_utility::Synchronized<ParameterTypes>...>;
   Tuple _parameters;
@@ -293,9 +300,9 @@ class Parameters {
 
   // For the parameter with name `Name` specify the function that is to be
   // called, when this parameter value changes.
-  template <ParameterName name, typename OnUpdateAction>
+  template <ParameterName Name, typename OnUpdateAction>
   auto setOnUpdateAction(OnUpdateAction onUpdateAction) {
-    constexpr auto index = _nameToIndex.at(name);
+    constexpr auto index = _nameToIndex.at(Name);
     std::get<index>(_parameters)
         .wlock()
         ->setOnUpdateAction(std::move(onUpdateAction));
diff --git a/src/util/ProgramOptionsHelpers.h b/src/util/ProgramOptionsHelpers.h
index bd804504d3..a4cb24b035 100644
--- a/src/util/ProgramOptionsHelpers.h
+++ b/src/util/ProgramOptionsHelpers.h
@@ -26,8 +26,9 @@ class NonNegative {
   size_t _value;
 };
 
-template <typename Stream, ad_utility::SimilarTo<NonNegative> NN>
-Stream& operator<<(Stream& stream, NN&& nonNegative) {
+CPP_template(typename Stream, typename NN)(
+    requires ad_utility::SimilarTo<NN, NonNegative>) Stream&
+operator<<(Stream& stream, NN&& nonNegative) {
   return stream << static_cast<size_t>(nonNegative);
 }
 
diff --git a/src/util/ProgressBar.h b/src/util/ProgressBar.h
index e71ec4c4ff..fdb4dd3d64 100644
--- a/src/util/ProgressBar.h
+++ b/src/util/ProgressBar.h
@@ -66,12 +66,12 @@ class ProgressBar {
   // outside (and be incremented there). That is because the calling code
   // typically has such a variable anyway (also for other purposes) and it
   // would we unnatural to have it originally in this class.
-  template <ad_utility::SimilarTo<size_t> SizeT>
-  ProgressBar(SizeT& numStepsProcessed, std::string displayStringPrefix,
-              size_t statisticsBatchSize = DEFAULT_PROGRESS_BAR_BATCH_SIZE,
-              SpeedDescriptionFunction getSpeedDescription =
-                  DEFAULT_SPEED_DESCRIPTION_FUNCTION,
-              DisplayUpdateOptions displayUpdateOptions = ReuseLine)
+  CPP_template(typename SizeT)(requires ad_utility::SimilarTo<SizeT, size_t>)
+      ProgressBar(SizeT& numStepsProcessed, std::string displayStringPrefix,
+                  size_t statisticsBatchSize = DEFAULT_PROGRESS_BAR_BATCH_SIZE,
+                  SpeedDescriptionFunction getSpeedDescription =
+                      DEFAULT_SPEED_DESCRIPTION_FUNCTION,
+                  DisplayUpdateOptions displayUpdateOptions = ReuseLine)
       : numStepsProcessed_(numStepsProcessed),
         displayStringPrefix_(std::move(displayStringPrefix)),
         statisticsBatchSize_(statisticsBatchSize),
diff --git a/src/util/Random.h b/src/util/Random.h
index b5af0d3d66..bcaa0b4e65 100644
--- a/src/util/Random.h
+++ b/src/util/Random.h
@@ -31,9 +31,8 @@ using RandomSeed = ad_utility::TypedIndex<unsigned int, "Seed">;
  * match (because of the std::enable_if) and there will be a compile-time
  * error.
  */
-template <typename Int>
-requires(std::is_integral_v<Int> && sizeof(Int) <= sizeof(uint64_t))
-class FastRandomIntGenerator {
+CPP_template(typename Int)(requires std::is_integral_v<Int> CPP_and(
+    sizeof(Int) <= sizeof(uint64_t))) class FastRandomIntGenerator {
  public:
   explicit FastRandomIntGenerator(
       RandomSeed seed = RandomSeed::make(std::random_device{}())) {
diff --git a/src/util/Serializer/SerializeArrayOrTuple.h b/src/util/Serializer/SerializeArrayOrTuple.h
index da001270be..3e17d29435 100644
--- a/src/util/Serializer/SerializeArrayOrTuple.h
+++ b/src/util/Serializer/SerializeArrayOrTuple.h
@@ -15,9 +15,10 @@ namespace ad_utility::serialization {
 
 // Allow trivial serialization for `std::array` if the `value_type` is already
 // `TriviallySerializable`.
-template <ad_utility::SimilarToArray T>
-requires TriviallySerializable<typename T::value_type>
-std::true_type allowTrivialSerialization(T, auto);
+CPP_template(typename T, typename U)(
+    requires ad_utility::SimilarToArray<T> CPP_and
+        TriviallySerializable<typename T::value_type>) std::true_type
+    allowTrivialSerialization(T, U);
 
 // A helper function to figure out whether all types contained in a tuple are
 // trivially seraizliable.
@@ -29,13 +30,14 @@ consteval bool tupleTriviallySerializableImpl() {
       [&result]<typename U>() { result = result && TriviallySerializable<U>; });
   return result;
 }
+template <typename T>
+CPP_concept ArrayOrTuple = ad_utility::isArray<std::decay_t<T>> ||
+                           ad_utility::similarToInstantiation<T, std::tuple>;
 }  // namespace detail
 
 // Serialization function for `std::array` and `std::tuple`.
 AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT(
-    ((ad_utility::isArray<std::decay_t<T>> ||
-      ad_utility::similarToInstantiation<
-          T, std::tuple>)&&!TriviallySerializable<T>)) {
+    detail::ArrayOrTuple<T> CPP_and CPP_NOT(TriviallySerializable<T>)) {
   using Arr = std::decay_t<T>;
   // Tuples are not technically not trivially copyable, but for the purpose of
   // serialization we still can safely `memcpy`. Note that for `std::array` the
diff --git a/src/util/Serializer/SerializeOptional.h b/src/util/Serializer/SerializeOptional.h
index 2218cf00e2..835d5078f2 100644
--- a/src/util/Serializer/SerializeOptional.h
+++ b/src/util/Serializer/SerializeOptional.h
@@ -11,8 +11,8 @@
 // Serialization for `std::optional<T>`
 namespace ad_utility::serialization {
 AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT(
-    (ad_utility::similarToInstantiation<T, std::optional> &&
-     !std::is_trivially_copyable_v<std::decay_t<T>>)) {
+    (ad_utility::similarToInstantiation<T, std::optional>)
+        CPP_and CPP_NOT(std::is_trivially_copyable_v<std::decay_t<T>>)) {
   if constexpr (ReadSerializer<S>) {
     bool hasValue;
     serializer >> hasValue;
diff --git a/src/util/Serializer/SerializeVector.h b/src/util/Serializer/SerializeVector.h
index 982e43e2ff..cd1e95ff72 100644
--- a/src/util/Serializer/SerializeVector.h
+++ b/src/util/Serializer/SerializeVector.h
@@ -36,8 +36,8 @@ AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT(
 
 /// Incrementally serialize a std::vector to disk without materializing it.
 /// Call `push` for each of the elements that will become part of the vector.
-template <typename T, WriteSerializer Serializer>
-class VectorIncrementalSerializer {
+CPP_template(typename T, typename Serializer)(
+    requires WriteSerializer<Serializer>) class VectorIncrementalSerializer {
  private:
   Serializer _serializer;
   uint64_t _startPosition;
diff --git a/src/util/Serializer/Serializer.h b/src/util/Serializer/Serializer.h
index 574604ed90..85575f193b 100644
--- a/src/util/Serializer/Serializer.h
+++ b/src/util/Serializer/Serializer.h
@@ -4,8 +4,7 @@
 
 // Library for symmetric serialization.
 
-#ifndef QLEVER_SERIALIZER_SERIALIZER
-#define QLEVER_SERIALIZER_SERIALIZER
+#pragma once
 
 #include "util/Forward.h"
 #include "util/TypeTraits.h"
@@ -57,35 +56,41 @@ class SerializationException : public std::runtime_error {
 class WriteSerializerTag {};
 class ReadSerializerTag {};
 
-/// A `WriteSerializer` can write from a span of bytes to some resource and has
-/// a public member type `using SerializerType = WriteSerializerTag`.
+// A `WriteSerializer` can write from a span of bytes to some resource and has
+// a public member type `using SerializerType = WriteSerializerTag`.
 template <typename S>
-concept WriteSerializer = requires(S s, const char* ptr, size_t numBytes) {
-  {
-    typename std::decay_t<S>::SerializerType{}
-  } -> std::same_as<WriteSerializerTag>;
-  { s.serializeBytes(ptr, numBytes) };
-};
+CPP_requires(writeSerializerRequires,
+             requires(S s, const char* ptr, size_t numBytes)(
+                 s.serializeBytes(ptr, numBytes),
+                 typename std::decay_t<S>::SerializerType{},
+                 concepts::requires_<std::same_as<typename S::SerializerType,
+                                                  WriteSerializerTag>>));
 
-/// A `ReadSerializer` can read to span of bytes from some resource and has a
-/// public alias `using SerializerType = ReadSerializerTag'`.
 template <typename S>
-concept ReadSerializer = requires(S s, char* ptr, size_t numBytes) {
-  {
-    typename std::decay_t<S>::SerializerType{}
-  } -> std::same_as<ReadSerializerTag>;
-  { s.serializeBytes(ptr, numBytes) };
-};
+concept WriteSerializer = CPP_requires_ref(writeSerializerRequires, S);
+
+// A `ReadSerializer` can read to span of bytes from some resource and has a
+// public alias `using SerializerType = ReadSerializerTag'`.
+template <typename S>
+CPP_requires(readSerializerRequires,
+             requires(S s, char* ptr, size_t numBytes)(
+                 s.serializeBytes(ptr, numBytes),
+                 typename std::decay_t<S>::SerializerType{},
+                 concepts::requires_<std::same_as<typename S::SerializerType,
+                                                  ReadSerializerTag>>));
+
+template <typename S>
+concept ReadSerializer = CPP_requires_ref(readSerializerRequires, S);
 
 /// A `Serializer` is either a `WriteSerializer` or a `ReadSerializer`
 template <typename S>
-concept Serializer = WriteSerializer<S> || ReadSerializer<S>;
+CPP_concept Serializer = WriteSerializer<S> || ReadSerializer<S>;
 
 /// If we try to serialize from a const object or reference, the serializer must
 /// be a `WriteSerializer`. The following type trait can be used to check this
 /// constraint at compile time.
-template <Serializer S, typename T>
-static constexpr bool SerializerMatchesConstness =
+CPP_template(typename S, typename T)(
+    requires Serializer<S>) static constexpr bool SerializerMatchesConstness =
     WriteSerializer<S> || !std::is_const_v<std::remove_reference_t<T>>;
 
 /**
@@ -112,21 +117,24 @@ static constexpr bool SerializerMatchesConstness =
  * - The second argument to `serialize` is a `T`, `T&`, `const T&`, `T&&` etc.
  * - If the `arg` is const then the serializer is a `WriteSerializer`.
  */
-#define AD_SERIALIZE_FUNCTION(T)                                       \
-  template <ad_utility::serialization::Serializer S,                   \
-            ad_utility::SimilarTo<T> U>                                \
-  requires ad_utility::serialization::SerializerMatchesConstness<S, U> \
-  void serialize(S& serializer, U&& arg)
+#define AD_SERIALIZE_FUNCTION(T)                                             \
+  CPP_template(typename S, typename U)(                                      \
+      requires ad_utility::serialization::Serializer<S> CPP_and              \
+          ad_utility::SimilarTo<U, T>                                        \
+              CPP_and ad_utility::serialization::SerializerMatchesConstness< \
+                  S, U>) void                                                \
+  serialize(S& serializer, U&& arg)
 
 /// Similar to `AD_SERIALIZE_FUNCTION` but defines a `friend` function to also
 /// access private members of a class. It is possible to declare the friend
 /// using `AD_SERIALIZE_FRIEND_FUNCTION(Type);` and to define it outside of the
 /// class with `AD_SERIALIZE_FUNCTION(Type){...}`
-#define AD_SERIALIZE_FRIEND_FUNCTION(T)                                \
-  template <ad_utility::serialization::Serializer S,                   \
-            ad_utility::SimilarTo<T> U>                                \
-  requires ad_utility::serialization::SerializerMatchesConstness<S, U> \
-  friend void serialize(S& serializer, U&& arg)
+#define AD_SERIALIZE_FRIEND_FUNCTION(T)                                        \
+  CPP_variadic_template(typename S, typename U)(                               \
+      requires ad_utility::serialization::Serializer<S> &&                     \
+      ad_utility::SimilarTo<U, T> &&                                           \
+      ad_utility::serialization::SerializerMatchesConstness<S, U>) friend void \
+  serialize(S& serializer, U&& arg)
 
 /**
  * Define `serialize` functions for all types that fulfill the `Constraint`.
@@ -139,21 +147,27 @@ static constexpr bool SerializerMatchesConstness =
  * `Serializer` , `WriteSerializer` and `ReadSerializer` are also true for
  * references to serializers. For an example usage see `SerializePair.h`.
  */
-#define AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT(Constraint)        \
-  template <ad_utility::serialization::Serializer S, typename T> \
-  requires(Constraint) void serialize(S& serializer, T&& arg)
+#define AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT(Constraint)       \
+  CPP_template(typename S, typename T)(                         \
+      requires ad_utility::serialization::Serializer<S> CPP_and \
+          Constraint) void                                      \
+  serialize(S& serializer, T&& arg)
 
 /// Similar to `AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT` but only for
 /// `WriteSerializer`s. For an example usage see `SerializeVector.h`
-#define AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT_WRITE(Constraint)       \
-  template <ad_utility::serialization::WriteSerializer S, typename T> \
-  requires(Constraint) void serialize(S& serializer, T&& arg)
+#define AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT_WRITE(Constraint)      \
+  CPP_template(typename S, typename T)(                              \
+      requires ad_utility::serialization::WriteSerializer<S> CPP_and \
+          Constraint) void                                           \
+  serialize(S& serializer, T&& arg)
 
 /// Similar to `AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT` but only for
 /// `ReadSerializer`s. For an example usage see `SerializeVector.h`
-#define AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT_READ(Constraint)       \
-  template <ad_utility::serialization::ReadSerializer S, typename T> \
-  requires(Constraint) void serialize(S& serializer, T&& arg)
+#define AD_SERIALIZE_FUNCTION_WITH_CONSTRAINT_READ(Constraint)      \
+  CPP_template(typename S, typename T)(                             \
+      requires ad_utility::serialization::ReadSerializer<S> CPP_and \
+          Constraint) void                                          \
+  serialize(S& serializer, T&& arg)
 
 /**
  * Operator that allows the short hand notation
@@ -161,17 +175,22 @@ static constexpr bool SerializerMatchesConstness =
  * instead of
  * `serialize(serializer, t)`
  */
-void operator|(Serializer auto& serializer, auto&& t) {
+CPP_template(typename S, typename T)(requires Serializer<S>) void operator|(
+    S& serializer, T&& t) {
   serialize(serializer, AD_FWD(t));
 }
 
 /// Serialization operator for explicitly writing to a serializer.
-void operator<<(WriteSerializer auto& serializer, const auto& t) {
+CPP_template(typename S, typename T)(requires WriteSerializer<S>) void
+operator<<(S& serializer, const T& t) {
   serializer | t;
 }
 
 /// Serialization operator for explicitly reading from a serializer.
-void operator>>(ReadSerializer auto& serializer, auto&& t) { serializer | t; }
+CPP_template(typename S, typename T)(requires ReadSerializer<S>) void
+operator>>(S& serializer, T&& t) {
+  serializer | t;
+}
 
 /// An empty struct that isn't needed by the users of this serialization
 /// framework. It is used internally to make argument-dependent lookup work.
@@ -210,18 +229,24 @@ struct TrivialSerializationHelperTag {};
  * void allowTrivialSerialization(std::same_as<Z> auto, auto);
  */
 template <typename T>
-concept TriviallySerializable =
-    requires(T t, TrivialSerializationHelperTag tag) {
-      // The `TrivialSerializationHelperTag` lets the argument-dependent lookup
-      // also find the `allowTrivialSerialization` function if it is defined in
-      // the `ad::serialization` namespace.
-      allowTrivialSerialization(t, tag);
-    } && std::is_trivially_copyable_v<std::decay_t<T>>;
+CPP_requires(
+    triviallySerializableRequires,
+    requires(T t, TrivialSerializationHelperTag tag)(
+        // The `TrivialSerializationHelperTag` lets the argument-dependent
+        // lookup also find the `allowTrivialSerialization` function if it is
+        // defined in the `ad::serialization` namespace.
+        allowTrivialSerialization(t, tag)));
+
+template <typename T>
+CPP_concept TriviallySerializable =
+    CPP_requires_ref(triviallySerializableRequires, T) &&
+    std::is_trivially_copyable_v<std::decay_t<T>>;
 
 /// Serialize function for `TriviallySerializable` types that works by simply
 /// serializing the binary object representation.
-template <Serializer S, TriviallySerializable T>
-void serialize(S& serializer, T&& t) {
+CPP_template(typename S, typename T)(
+    requires Serializer<S> CPP_and
+        TriviallySerializable<T>) void serialize(S& serializer, T&& t) {
   if constexpr (WriteSerializer<S>) {
     serializer.serializeBytes(reinterpret_cast<const char*>(&t), sizeof(t));
   } else {
@@ -232,12 +257,10 @@ void serialize(S& serializer, T&& t) {
 
 /// Arithmetic types (the builtins like int, char, double) can be trivially
 /// serialized.
-template <typename T>
-requires std::is_arithmetic_v<std::decay_t<T>>
-[[maybe_unused]] std::true_type allowTrivialSerialization(T, auto) {
+CPP_template(typename T,
+             typename U)(requires std::is_arithmetic_v<std::decay_t<T>>)
+    [[maybe_unused]] std::true_type allowTrivialSerialization(T, U) {
   return {};
 }
 
 }  // namespace ad_utility::serialization
-
-#endif  // QLEVER_SERIALIZER_SERIALIZER
diff --git a/src/util/StringUtils.h b/src/util/StringUtils.h
index 315d9daa8e..c18315c9c8 100644
--- a/src/util/StringUtils.h
+++ b/src/util/StringUtils.h
@@ -188,7 +188,7 @@ constexpr bool constantTimeEquals(std::string_view view1,
 
 // _________________________________________________________________________
 CPP_template_def(typename Range)(
-    requires ql::ranges::input_range<Range> CPP_and
+    requires ql::ranges::input_range<Range> CPP_and_def
         ad_utility::Streamable<std::iter_reference_t<ql::ranges::iterator_t<
             Range>>>) void lazyStrJoin(std::ostream* stream, Range&& r,
                                        std::string_view separator) {
@@ -214,7 +214,7 @@ CPP_template_def(typename Range)(
 
 // _________________________________________________________________________
 CPP_template_def(typename Range)(
-    requires ql::ranges::input_range<Range> CPP_and ad_utility::Streamable<
+    requires ql::ranges::input_range<Range> CPP_and_def ad_utility::Streamable<
         std::iter_reference_t<ql::ranges::iterator_t<Range>>>) std::string
     lazyStrJoin(Range&& r, std::string_view separator) {
   std::ostringstream stream;
diff --git a/src/util/Synchronized.h b/src/util/Synchronized.h
index 3130b2b222..817fc695a4 100644
--- a/src/util/Synchronized.h
+++ b/src/util/Synchronized.h
@@ -98,9 +98,10 @@ class Synchronized {
 
   /// Constructor that is not copy or move, tries to instantiate the underlying
   /// type via perfect forwarding (this includes the default constructor)
-  template <typename Arg, typename... Args>
-  requires(!std::same_as<std::remove_cvref_t<Arg>, Synchronized>)
-  explicit(sizeof...(Args) == 0) Synchronized(Arg&& arg, Args&&... args)
+  CPP_template(typename Arg, typename... Args)(requires CPP_NOT(
+      std::same_as<std::remove_cvref_t<Arg>,
+                   Synchronized>)) explicit(sizeof...(Args) == 0)
+      Synchronized(Arg&& arg, Args&&... args)
       : data_{AD_FWD(arg), AD_FWD(args)...}, m_{} {}
 
   template <typename... Args>
diff --git a/src/util/ThreadSafeQueue.h b/src/util/ThreadSafeQueue.h
index 6c6828d411..2d82a77361 100644
--- a/src/util/ThreadSafeQueue.h
+++ b/src/util/ThreadSafeQueue.h
@@ -217,9 +217,9 @@ class OrderedThreadSafeQueue {
 
 // A concept for one of the thread-safe queue types above
 template <typename T>
-concept IsThreadsafeQueue =
-    ad_utility::similarToInstantiation<T, ThreadSafeQueue> ||
-    ad_utility::similarToInstantiation<T, OrderedThreadSafeQueue>;
+CPP_concept IsThreadsafeQueue =
+    (ad_utility::similarToInstantiation<T, ThreadSafeQueue> ||
+     ad_utility::similarToInstantiation<T, OrderedThreadSafeQueue>);
 
 namespace detail {
 // A helper function for setting up a producer for one of the threadsafe
@@ -229,9 +229,10 @@ namespace detail {
 // the producer returns `nullopt`, `numThreads` is decremented, and the queue is
 // finished if `numThreads <= 0`. All exceptions that happen during the
 // execution of `producer` are propagated to the queue.
-template <IsThreadsafeQueue Queue, std::invocable Producer>
-auto makeQueueTask(Queue& queue, Producer producer,
-                   std::atomic<int64_t>& numThreads) {
+CPP_template(typename Queue, typename Producer)(
+    requires IsThreadsafeQueue<Queue> CPP_and std::invocable<
+        Producer>) auto makeQueueTask(Queue& queue, Producer producer,
+                                      std::atomic<int64_t>& numThreads) {
   return [&queue, producer = std::move(producer), &numThreads] {
     try {
       while (auto opt = producer()) {
diff --git a/src/util/Timer.h b/src/util/Timer.h
index 3c6974bf78..71c6315291 100644
--- a/src/util/Timer.h
+++ b/src/util/Timer.h
@@ -52,8 +52,9 @@ class Timer {
 
   // Convert any `std::chrono::duration` to the underlying `Duration` type
   // of the `Timer` class.
-  template <ad_utility::isInstantiation<chr::duration> T>
-  static Duration toDuration(T duration) {
+  CPP_template(typename T)(
+      requires ad_utility::isInstantiation<T, chr::duration>) static Duration
+      toDuration(T duration) {
     return chr::duration_cast<Duration>(duration);
   }
 
diff --git a/src/util/TransparentFunctors.h b/src/util/TransparentFunctors.h
index 1b889a0796..1e6f307365 100644
--- a/src/util/TransparentFunctors.h
+++ b/src/util/TransparentFunctors.h
@@ -58,14 +58,14 @@ struct GetImpl {
 // Implementation of `getIf` (see below).
 template <typename T>
 struct GetIfImpl {
-  template <typename Ptr>
-  requires std::is_pointer_v<std::remove_cvref_t<Ptr>>
-  constexpr decltype(auto) operator()(Ptr& variantPtr) const {
+  CPP_template(typename Ptr)(requires std::is_pointer_v<
+                             std::remove_cvref_t<Ptr>>) constexpr decltype(auto)
+  operator()(Ptr& variantPtr) const {
     return std::get_if<T>(variantPtr);
   }
-  template <typename Ptr>
-  requires(!std::is_pointer_v<std::remove_cvref_t<Ptr>>)
-  constexpr decltype(auto) operator()(Ptr& variant) const {
+  CPP_template(typename Ptr)(requires CPP_NOT(
+      std::is_pointer_v<std::remove_cvref_t<Ptr>>)) constexpr decltype(auto)
+  operator()(Ptr& variant) const {
     return std::get_if<T>(&variant);
   }
 };
diff --git a/src/util/TypeTraits.h b/src/util/TypeTraits.h
index 8390667a85..cd7f2f82b4 100644
--- a/src/util/TypeTraits.h
+++ b/src/util/TypeTraits.h
@@ -34,7 +34,7 @@ the 'call' `IsInstantiationOf<A>::Instantiation<B<int>>::value` and
 template <template <typename...> typename Template>
 struct IsInstantiationOf {
   template <typename T>
-  struct Instantiation;
+  struct Instantiation : std::false_type {};
 
   template <typename... Ts>
   struct Instantiation<Template<Ts...>> : std::true_type {};
@@ -85,7 +85,7 @@ struct FirstWrapper : public std::type_identity<T> {};
 /// isInstantiation<std::vector<int>, std::vector> == true;
 /// isInstantiation<const std::vector<int>&, std::vector> == false;
 template <typename T, template <typename...> typename TemplatedType>
-concept isInstantiation =
+CPP_concept isInstantiation =
     detail::IsInstantiationOf<TemplatedType>::template Instantiation<T>::value;
 
 /// The concept is fulfilled iff `T` is `ad_utility::SimilarTo` an
@@ -94,16 +94,25 @@ concept isInstantiation =
 /// similarToInstantiation<std::vector, std::vector<int>> == true;
 /// similarToInstantiation<std::vector, const std::vector<int>&> == true;
 template <typename T, template <typename...> typename TemplatedType>
-concept similarToInstantiation =
+CPP_concept similarToInstantiation =
     isInstantiation<std::decay_t<T>, TemplatedType>;
 
+/// @brief The concept is fulfilled if `T` is an instantiation of any
+/// of the types passed in ...Ts
+///
+/// similarToAnyInstantiationOf<std::vector, std::vector<int>,
+/// std::vector<char>> == true
+template <typename T, template <typename...> typename... Ts>
+CPP_concept similarToAnyInstantiationOf =
+    (... || similarToInstantiation<T, Ts>);
+
 /// isVector<T> is true if and only if T is an instantiation of std::vector
 template <typename T>
 constexpr static bool isVector = isInstantiation<T, std::vector>;
 
 /// isTuple<T> is true if and only if T is an instantiation of std::tuple
 template <typename T>
-constexpr static bool isTuple = isInstantiation<T, std::tuple>;
+CPP_concept isTuple = isInstantiation<T, std::tuple>;
 
 /// isVariant<T> is true if and only if T is an instantiation of std::variant
 template <typename T>
@@ -118,7 +127,7 @@ constexpr static bool isArray<std::array<T, N>> = true;
 
 // `SimilarToArray` is also true for `std::array<...>&`, etc.
 template <typename T>
-concept SimilarToArray = isArray<std::decay_t<T>>;
+CPP_concept SimilarToArray = isArray<std::decay_t<T>>;
 
 /// Two types are similar, if they are the same when we remove all cv (const or
 /// volatile) qualifiers and all references
@@ -128,11 +137,11 @@ constexpr static bool isSimilar =
 
 /// A concept for similarity
 template <typename T, typename U>
-concept SimilarTo = isSimilar<T, U>;
+CPP_concept SimilarTo = isSimilar<T, U>;
 
 /// True iff `T` is similar (see above) to any of the `Ts...`.
 template <typename T, typename... Ts>
-concept SimilarToAny = (... || isSimilar<T, Ts>);
+CPP_concept SimilarToAny = (... || isSimilar<T, Ts>);
 
 /// True iff `T` is the same as any of the `Ts...`.
 template <typename T, typename... Ts>
@@ -144,14 +153,14 @@ namespace detail).
 */
 namespace detail {
 template <typename T, typename Template>
-struct SimilarToAnyTypeInImpl;
+struct SimilarToAnyTypeInImpl : std::false_type {};
 
 template <typename T, template <typename...> typename Template, typename... Ts>
 struct SimilarToAnyTypeInImpl<T, Template<Ts...>>
     : std::integral_constant<bool, SimilarToAny<T, Ts...>> {};
 
 template <typename T, typename Template>
-struct SameAsAnyTypeInImpl;
+struct SameAsAnyTypeInImpl : std::false_type {};
 
 template <typename T, template <typename...> typename Template, typename... Ts>
 struct SameAsAnyTypeInImpl<T, Template<Ts...>>
@@ -165,14 +174,15 @@ or `std::variant`). and `T` is `isSimilar` (see above) to any of the type
 parameters.
 */
 template <typename T, typename Template>
-concept SimilarToAnyTypeIn = detail::SimilarToAnyTypeInImpl<T, Template>::value;
+CPP_concept SimilarToAnyTypeIn =
+    detail::SimilarToAnyTypeInImpl<T, Template>::value;
 
 /*
 Equivalent to `SimilarToAnyTypeIn` (see above), but checks for exactly matching
 types via `std::same_as`.
 */
 template <typename T, typename Template>
-concept SameAsAnyTypeIn = detail::SameAsAnyTypeInImpl<T, Template>::value;
+CPP_concept SameAsAnyTypeIn = detail::SameAsAnyTypeInImpl<T, Template>::value;
 
 /// A templated bool that is always false,
 /// independent of the template parameter.
@@ -181,28 +191,30 @@ constexpr static bool alwaysFalse = false;
 
 /// From the type Tuple (std::tuple<A, B, C....>) creates the type
 /// std::tuple<TypeLifter<A>, TypeLifter<B>,...>
-template <typename Tuple, template <typename> typename TypeLifter>
-requires isTuple<Tuple> using LiftedTuple = typename detail::LiftInnerTypes<
-    std::tuple, TypeLifter>::template TypeToLift<Tuple>::LiftedType;
+CPP_template(typename Tuple,
+             template <typename>
+             typename TypeLifter)(requires isTuple<Tuple>) using LiftedTuple =
+    typename detail::LiftInnerTypes<
+        std::tuple, TypeLifter>::template TypeToLift<Tuple>::LiftedType;
 
 /// From the type Variant (std::variant<A, B, C....>) creates the type
 /// std::variant<TypeLifter<A>, TypeLifter<B>,...>
-template <typename Variant, template <typename> typename TypeLifter>
-requires isVariant<Variant>
-using LiftedVariant = typename detail::LiftInnerTypes<
-    std::variant, TypeLifter>::template TypeToLift<Variant>::LiftedType;
+CPP_template(typename Variant, template <typename> typename TypeLifter)(
+    requires isVariant<Variant>) using LiftedVariant =
+    typename detail::LiftInnerTypes<
+        std::variant, TypeLifter>::template TypeToLift<Variant>::LiftedType;
 
 /// From the type std::tuple<A, B, ...> makes the type std::variant<A, B, ...>
-template <typename Tuple>
-requires isTuple<Tuple>
-using TupleToVariant = typename detail::TupleToVariantImpl<Tuple>::type;
+CPP_template(typename Tuple)(requires isTuple<Tuple>) using TupleToVariant =
+    typename detail::TupleToVariantImpl<Tuple>::type;
 
 /// From the types X = std::tuple<A, ... , B>, , Y = std::tuple<C, ..., D>...
 /// makes the type TupleCat<X, Y> = std::tuple<A, ..., B, C, ..., D, ...> (works
 /// for an arbitrary number of tuples as template parameters.
 template <typename... Tuples>
-requires(... && isTuple<Tuples>)
-using TupleCat = decltype(std::tuple_cat(std::declval<Tuples&>()...));
+using TupleCat =
+    std::enable_if_t<(isTuple<Tuples> && ...),
+                     decltype(std::tuple_cat(std::declval<Tuples&>()...))>;
 
 /// A generalized version of std::visit that also supports non-variant
 /// parameters. Each `parameterOrVariant` of type T that is not a std::variant
@@ -244,18 +256,48 @@ auto applyFunctionToEachElementOfTuple(Function&& f, Tuple&& tuple) {
 
 // Return the last type of variadic template arguments.
 template <typename... Ts>
-requires(sizeof...(Ts) > 0) using Last = typename detail::LastT<Ts...>::type;
+using Last = typename std::enable_if_t<(sizeof...(Ts) > 0),
+                                       typename detail::LastT<Ts...>::type>;
 
 // Return the first type of variadic template arguments.
 template <typename... Ts>
-requires(sizeof...(Ts) > 0)
-using First = typename detail::FirstWrapper<Ts...>::type;
+using First =
+    typename std::enable_if_t<(sizeof...(Ts) > 0),
+                              typename detail::FirstWrapper<Ts...>::type>;
 
 /// Concept for `std::is_invocable_r_v`.
 template <typename Func, typename R, typename... ArgTypes>
+// TODO<joka921, gpcicciuca> turn back to `concept` and fix the remaining
+// places.
 concept InvocableWithConvertibleReturnType =
     std::is_invocable_r_v<R, Func, ArgTypes...>;
 
+// The implementation of `InvokeResultSfinaeFriendly`
+namespace invokeResultSfinaeFriendly::detail {
+template <typename T, typename... Args>
+struct InvalidInvokeResult {
+  InvalidInvokeResult() = delete;
+  ~InvalidInvokeResult() = delete;
+};
+template <typename T, typename... Args>
+constexpr auto getInvokeResultImpl() {
+  if constexpr (std::is_invocable_v<T, Args...>) {
+    return std::type_identity<std::invoke_result_t<T, Args...>>{};
+  } else {
+    return std::type_identity<InvalidInvokeResult<T, Args...>>{};
+  }
+}
+}  // namespace invokeResultSfinaeFriendly::detail
+
+// If `std::is_invocable_v<T, Args...>`, then this is `std::invoke_result_t<T ,
+// Args...>` , otherwise it is an internal type that can be neither constructed
+// nor destructed. This is useful in SFINAE-contexts, where
+// `std::invoke_result_t` leads to hard compiler errors if it doesn't exist.
+template <typename T, typename... Args>
+using InvokeResultSfinaeFriendly =
+    typename decltype(invokeResultSfinaeFriendly::detail::getInvokeResultImpl<
+                      T, Args...>())::type;
+
 /*
 The following concepts are similar to `std::is_invocable_r_v` with the following
 difference: `std::is_invocable_r_v` only checks that the return type of a
@@ -272,16 +314,18 @@ are the same when ignoring `const`, `volatile`, and reference qualifiers.
 template <typename Fn, typename Ret, typename... Args>
 concept InvocableWithSimilarReturnType =
     std::invocable<Fn, Args...> &&
-    isSimilar<std::invoke_result_t<Fn, Args...>, Ret>;
+    isSimilar<InvokeResultSfinaeFriendly<Fn, Args...>, Ret>;
 
 /*
 @brief Require `Fn` to be invocable with `Args...` and the return type to be
  `Ret`.
 */
+// TODO<joka921, gpcicciuca> turn back to `concept` and fix the remaining
+// places.
 template <typename Fn, typename Ret, typename... Args>
 concept InvocableWithExactReturnType =
     std::invocable<Fn, Args...> &&
-    std::same_as<std::invoke_result_t<Fn, Args...>, Ret>;
+    std::same_as<InvokeResultSfinaeFriendly<Fn, Args...>, Ret>;
 
 /*
 @brief Require `Fn` to be regular invocable with `Args...` and the return type
@@ -295,7 +339,7 @@ For more information see: https://en.cppreference.com/w/cpp/concepts/invocable
 template <typename Fn, typename Ret, typename... Args>
 concept RegularInvocableWithSimilarReturnType =
     std::regular_invocable<Fn, Args...> &&
-    isSimilar<std::invoke_result_t<Fn, Args...>, Ret>;
+    isSimilar<InvokeResultSfinaeFriendly<Fn, Args...>, Ret>;
 
 /*
 @brief Require `Fn` to be regular invocable with `Args...` and the return type
@@ -309,7 +353,7 @@ For more information see: https://en.cppreference.com/w/cpp/concepts/invocable
 template <typename Fn, typename Ret, typename... Args>
 concept RegularInvocableWithExactReturnType =
     std::regular_invocable<Fn, Args...> &&
-    std::same_as<std::invoke_result_t<Fn, Args...>, Ret>;
+    std::same_as<InvokeResultSfinaeFriendly<Fn, Args...>, Ret>;
 
 // True iff `T` is a value type or an rvalue reference. Can be used to force
 // rvalue references for templated functions: For example: void f(auto&& x) //
diff --git a/src/util/UniqueCleanup.h b/src/util/UniqueCleanup.h
index 77305029ad..3c40f21afc 100644
--- a/src/util/UniqueCleanup.h
+++ b/src/util/UniqueCleanup.h
@@ -8,14 +8,15 @@
 #include <concepts>
 #include <functional>
 
+#include "backports/concepts.h"
 #include "util/ResetWhenMoved.h"
 
 namespace ad_utility::unique_cleanup {
 
 /// Wrapper class that allows to call a function
 /// just before the wrapper value T is destroyed.
-template <std::move_constructible T, typename Func = std::function<void(T&&)>>
-class UniqueCleanup {
+CPP_template(typename T, typename Func = std::function<void(T&&)>)(
+    requires std::move_constructible<T>) class UniqueCleanup {
   /// Boolean indicating if object was not moved out of
   ResetWhenMoved<bool, false> active_ = true;
   /// Wrapped value
diff --git a/src/util/ValueSizeGetters.h b/src/util/ValueSizeGetters.h
index 34be2569d4..1801b9b2d2 100644
--- a/src/util/ValueSizeGetters.h
+++ b/src/util/ValueSizeGetters.h
@@ -18,19 +18,20 @@ Concept for `ValueSizeGetter`. Must be default- initializable, regular invocable
 with the given value type as const l-value reference and return a `MemorySize`.
 */
 template <typename T, typename ValueType>
-concept ValueSizeGetter =
+CPP_concept ValueSizeGetter =
     std::default_initializable<T> &&
     RegularInvocableWithSimilarReturnType<T, MemorySize, const ValueType&>;
 
 // A templated default value size getter. Can be specialized for additional
 // custom types.
-template <typename T>
+template <typename T, typename = void>
 struct DefaultValueSizeGetter;
 
 // Trivially copyable types do not own heap memory (otherwise they are
 // incorred), so we just use sizeof.
 template <typename T>
-requires std::is_trivially_copyable_v<T> struct DefaultValueSizeGetter<T> {
+struct DefaultValueSizeGetter<
+    T, std::enable_if_t<std::is_trivially_copyable_v<T>>> {
   constexpr MemorySize operator()(const T&) const {
     return MemorySize::bytes(sizeof(T));
   }
diff --git a/src/util/Views.h b/src/util/Views.h
index ddcf867d3f..2c99db4233 100644
--- a/src/util/Views.h
+++ b/src/util/Views.h
@@ -15,6 +15,14 @@
 
 namespace ad_utility {
 
+namespace detail {
+template <typename R>
+CPP_requires(can_empty_, requires(const R& range)(ql::ranges::empty(range)));
+
+template <typename R>
+CPP_concept RangeCanEmpty = CPP_requires_ref(can_empty_, R);
+}  // namespace detail
+
 /// Takes a view and yields the elements of the same view, but skips over
 /// consecutive duplicates.
 template <typename SortedView,
@@ -89,10 +97,10 @@ CPP_template(typename UnderlyingRange, bool supportConst = true)(
         ql::concepts::movable<UnderlyingRange>) class OwningView
     : public ql::ranges::view_interface<OwningView<UnderlyingRange>> {
  private:
-  UnderlyingRange underlyingRange_ = UnderlyingRange();
+  UnderlyingRange underlyingRange_;
 
  public:
-  OwningView() requires std::default_initializable<UnderlyingRange> = default;
+  OwningView() = default;
 
   constexpr explicit OwningView(UnderlyingRange&& underlyingRange) noexcept(
       std::is_nothrow_move_constructible_v<UnderlyingRange>)
@@ -115,49 +123,45 @@ CPP_template(typename UnderlyingRange, bool supportConst = true)(
     return std::move(underlyingRange_);
   }
 
-  constexpr ql::ranges::iterator_t<UnderlyingRange> begin() {
-    return ql::ranges::begin(underlyingRange_);
-  }
+  constexpr auto begin() { return ql::ranges::begin(underlyingRange_); }
 
-  constexpr ql::ranges::sentinel_t<UnderlyingRange> end() {
-    return ql::ranges::end(underlyingRange_);
-  }
+  constexpr auto end() { return ql::ranges::end(underlyingRange_); }
 
-  constexpr auto begin() const
-      requires(supportConst && ql::ranges::range<const UnderlyingRange>) {
+  CPP_auto_member constexpr auto CPP_fun(begin)()(
+      const  //
+      requires(supportConst&& ql::ranges::range<const UnderlyingRange>)) {
     return ql::ranges::begin(underlyingRange_);
   }
 
-  constexpr auto end() const
-      requires(supportConst && ql::ranges::range<const UnderlyingRange>) {
+  CPP_auto_member constexpr auto CPP_fun(end)()(
+      const  //
+      requires(supportConst&& ql::ranges::range<const UnderlyingRange>)) {
     return ql::ranges::end(underlyingRange_);
   }
 
-  constexpr bool empty()
-      requires requires { ql::ranges::empty(underlyingRange_); } {
-    return ql::ranges::empty(underlyingRange_);
-  }
-
-  constexpr bool empty() const
-      requires requires { ql::ranges::empty(underlyingRange_); } {
+  CPP_member constexpr auto empty() const
+      -> CPP_ret(bool)(requires detail::RangeCanEmpty<const UnderlyingRange>) {
     return ql::ranges::empty(underlyingRange_);
   }
 
-  constexpr auto size() requires ql::ranges::sized_range<UnderlyingRange> {
+  CPP_member constexpr auto size()
+      -> CPP_ret(size_t)(requires ql::ranges::sized_range<UnderlyingRange>) {
     return ql::ranges::size(underlyingRange_);
   }
 
-  constexpr auto size() const
-      requires ql::ranges::sized_range<const UnderlyingRange> {
+  CPP_member constexpr auto size() const -> CPP_ret(size_t)(
+      requires ql::ranges::sized_range<const UnderlyingRange>) {
     return ql::ranges::size(underlyingRange_);
   }
 
-  constexpr auto data() requires ql::ranges::contiguous_range<UnderlyingRange> {
+  CPP_auto_member constexpr auto CPP_fun(data)()(
+      requires ql::ranges::contiguous_range<UnderlyingRange>) {
     return ql::ranges::data(underlyingRange_);
   }
 
-  constexpr auto data() const
-      requires ql::ranges::contiguous_range<const UnderlyingRange> {
+  CPP_auto_member constexpr auto CPP_fun(data)()(
+      const  //
+      requires ql::ranges::contiguous_range<const UnderlyingRange>) {
     return ql::ranges::data(underlyingRange_);
   }
 };
@@ -206,20 +210,20 @@ template <typename View>
 struct BufferedAsyncView : InputRangeMixin<BufferedAsyncView<View>> {
   View view_;
   uint64_t blockSize_;
-  bool finished_ = false;
+  mutable bool finished_ = false;
 
-  explicit BufferedAsyncView(View view, uint64_t blockSize)
+  explicit BufferedAsyncView(View&& view, uint64_t blockSize)
       : view_{std::move(view)}, blockSize_{blockSize} {
     AD_CONTRACT_CHECK(blockSize_ > 0);
   }
 
-  ql::ranges::iterator_t<View> it_;
+  mutable ql::ranges::iterator_t<View> it_;
   ql::ranges::sentinel_t<View> end_ = ql::ranges::end(view_);
   using value_type = ql::ranges::range_value_t<View>;
-  std::future<std::vector<value_type>> future_;
+  mutable std::future<std::vector<value_type>> future_;
 
-  std::vector<value_type> buffer_;
-  std::vector<value_type> getNextBlock() {
+  mutable std::vector<value_type> buffer_;
+  std::vector<value_type> getNextBlock() const {
     std::vector<value_type> buffer;
     buffer.reserve(blockSize_);
     size_t i = 0;
@@ -268,18 +272,21 @@ auto bufferedAsyncView(View view, uint64_t blockSize) {
 // `ql::views::iota(0, size_t(INT_MAX) + 1)` leads to undefined behavior
 // because of an integer overflow, but `ad_utility::integerRange(size_t(INT_MAX)
 // + 1)` is perfectly safe and behaves as expected.
-template <std::unsigned_integral Int>
-auto integerRange(Int upperBound) {
+CPP_template(typename Int)(
+    requires std::unsigned_integral<Int>) auto integerRange(Int upperBound) {
   return ql::views::iota(Int{0}, upperBound);
 }
 
 // The implementation of `inPlaceTransformView`, see below for details.
 namespace detail {
-template <typename Range, ad_utility::InvocableWithExactReturnType<
-                              void, ql::ranges::range_reference_t<Range>>
-                              Transformation>
-requires(ql::ranges::view<Range> && ql::ranges::input_range<Range>)
-auto inPlaceTransformViewImpl(Range range, Transformation transformation) {
+CPP_template(typename Range, typename Transformation)(
+    requires ad_utility::InvocableWithExactReturnType<
+        Transformation, void, ql::ranges::range_reference_t<Range>>
+        CPP_and ql::ranges::view<Range>
+            CPP_and ql::ranges::input_range<
+                Range>) auto inPlaceTransformViewImpl(Range range,
+                                                      Transformation
+                                                          transformation) {
   // Take a range and yield pairs of [pointerToElementOfRange,
   // boolThatIsInitiallyFalse]. The bool is yielded as a reference and if its
   // value is changed, that change will be stored until the next element is
diff --git a/src/util/antlr/ANTLRErrorHandling.h b/src/util/antlr/ANTLRErrorHandling.h
index 9c52619abb..ee042c6c02 100644
--- a/src/util/antlr/ANTLRErrorHandling.h
+++ b/src/util/antlr/ANTLRErrorHandling.h
@@ -13,6 +13,7 @@
 #include "Recognizer.h"
 #include "Token.h"
 #include "absl/strings/str_cat.h"
+#include "backports/concepts.h"
 #include "util/ParseException.h"
 #include "util/antlr/GenerateAntlrExceptionMetadata.h"
 
@@ -30,11 +31,12 @@ antlr error message are included as exception cause.
 For an example of a valid `GrammarParseException` see
 `InvalidSparqlQueryException`.
 */
-template <typename GrammarParseException>
-requires std::derived_from<GrammarParseException, ParseException> &&
-         std::constructible_from<GrammarParseException, std::string_view,
-                                 std::optional<ExceptionMetadata>>
-struct ThrowingErrorListener : public antlr4::BaseErrorListener {
+CPP_template(typename GrammarParseException)(
+    requires std::derived_from<GrammarParseException, ParseException> CPP_and
+        std::constructible_from<
+            GrammarParseException, std::string_view,
+            std::optional<ExceptionMetadata>>) struct ThrowingErrorListener
+    : public antlr4::BaseErrorListener {
   void syntaxError(antlr4::Recognizer* recognizer,
                    antlr4::Token* offendingSymbol, size_t line,
                    size_t charPositionInLine, const std::string& msg,
diff --git a/src/util/http/HttpServer.h b/src/util/http/HttpServer.h
index 554714732a..d146fa48c5 100644
--- a/src/util/http/HttpServer.h
+++ b/src/util/http/HttpServer.h
@@ -48,12 +48,11 @@ using tcp = boost::asio::ip::tcp;  // from <boost/asio/ip/tcp.hpp>
  * a `net::awaitable<void>`. It is only called if the request is a valid
  * websocket upgrade request and the URL represents a valid path.
  */
-template <typename HttpHandler,
-          ad_utility::InvocableWithExactReturnType<
-              net::awaitable<void>, const http::request<http::string_body>&,
-              tcp::socket>
-              WebSocketHandler>
-class HttpServer {
+CPP_template(typename HttpHandler, typename WebSocketHandler)(
+    requires ad_utility::InvocableWithExactReturnType<
+        WebSocketHandler, net::awaitable<void>,
+        const http::request<http::string_body>&,
+        tcp::socket>) class HttpServer {
  private:
   HttpHandler httpHandler_;
   int numServerThreads_;
@@ -72,12 +71,25 @@ class HttpServer {
   /// Construct from the `queryRegistry`, port and ip address, on which this
   /// server will listen, as well as the HttpHandler. This constructor only
   /// initializes several member functions
-  explicit HttpServer(
-      unsigned short port, std::string_view ipAddress = "0.0.0.0",
-      int numServerThreads = 1, HttpHandler handler = HttpHandler{},
-      ad_utility::InvocableWithConvertibleReturnType<WebSocketHandler,
-                                                     net::io_context&> auto
-          webSocketHandlerSupplier = {})
+  ///
+  // Note: The following constraint can not be written with a single declaration
+  // in the `std::enable_if_t` world, because of the following bug in GCC 11:
+  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105268
+  template <typename HandlerSupplier>
+  static constexpr bool isSupplier =
+      ad_utility::InvocableWithConvertibleReturnType<
+          HandlerSupplier, WebSocketHandler, net::io_context&>;
+  CPP_template_2(typename HandlerSupplier)(
+      requires isSupplier<
+          HandlerSupplier>) explicit HttpServer(unsigned short port,
+                                                std::string_view ipAddress =
+                                                    "0.0.0.0",
+                                                int numServerThreads = 1,
+                                                HttpHandler handler =
+                                                    HttpHandler{},
+                                                HandlerSupplier
+                                                    webSocketHandlerSupplier =
+                                                        {})
       : httpHandler_{std::move(handler)},
         // We need at least two threads to avoid blocking.
         // TODO<joka921> why is that?
diff --git a/src/util/http/HttpUtils.h b/src/util/http/HttpUtils.h
index 9c6875f683..fce14d767f 100644
--- a/src/util/http/HttpUtils.h
+++ b/src/util/http/HttpUtils.h
@@ -82,6 +82,7 @@ static constexpr bool isHttpRequest = false;
 template <typename Body, typename Fields>
 static constexpr bool isHttpRequest<http::request<Body, Fields>> = true;
 
+// TODO<joka921, gpicciuca> port back
 template <typename T>
 concept HttpRequest = isHttpRequest<T>;
 
@@ -93,9 +94,13 @@ concept HttpRequest = isHttpRequest<T>;
  * @param mediaType The media type of the response.
  * @return A http::response<http::string_body> which is ready to be sent.
  */
-auto createHttpResponseFromString(std::string body, http::status status,
-                                  const HttpRequest auto& request,
-                                  MediaType mediaType) {
+CPP_template(typename RequestType)(
+    requires HttpRequest<
+        RequestType>) auto createHttpResponseFromString(std::string body,
+                                                        http::status status,
+                                                        const RequestType&
+                                                            request,
+                                                        MediaType mediaType) {
   http::response<http::string_body> response{status, request.version()};
   response.set(http::field::content_type, toString(mediaType));
   response.keep_alive(request.keep_alive());
@@ -107,8 +112,11 @@ auto createHttpResponseFromString(std::string body, http::status status,
 
 /// Create a HttpResponse from a string with status 200 OK. Otherwise behaves
 /// the same as createHttpResponseFromString.
-static auto createOkResponse(std::string text, const HttpRequest auto& request,
-                             MediaType mediaType) {
+CPP_template(typename RequestType)(
+    requires HttpRequest<
+        RequestType>) static auto createOkResponse(std::string text,
+                                                   const RequestType& request,
+                                                   MediaType mediaType) {
   return createHttpResponseFromString(std::move(text), http::status::ok,
                                       request, mediaType);
 }
@@ -116,9 +124,13 @@ static auto createOkResponse(std::string text, const HttpRequest auto& request,
 /// Assign the generator to the body of the response. If a supported
 /// compression is specified in the request, this method is applied to the
 /// body and the corresponding response headers are set.
-static void setBody(http::response<streamable_body>& response,
-                    const HttpRequest auto& request,
-                    cppcoro::generator<std::string>&& generator) {
+CPP_template(typename RequestType)(
+    requires HttpRequest<
+        RequestType>) static void setBody(http::response<streamable_body>&
+                                              response,
+                                          const RequestType& request,
+                                          cppcoro::generator<std::string>&&
+                                              generator) {
   using ad_utility::content_encoding::CompressionMethod;
 
   CompressionMethod method =
@@ -135,9 +147,13 @@ static void setBody(http::response<streamable_body>& response,
 }
 
 /// Create a HttpResponse from a generator with status 200 OK.
-static auto createOkResponse(cppcoro::generator<std::string>&& generator,
-                             const HttpRequest auto& request,
-                             MediaType mediaType) {
+CPP_template(typename RequestType)(
+    requires HttpRequest<
+        RequestType>) static auto createOkResponse(cppcoro::
+                                                       generator<std::string>&&
+                                                           generator,
+                                                   const RequestType& request,
+                                                   MediaType mediaType) {
   http::response<streamable_body> response{http::status::ok, request.version()};
   response.set(http::field::content_type, toString(mediaType));
   response.keep_alive(request.keep_alive());
@@ -168,22 +184,33 @@ static auto createJsonResponse(const nlohmann::json& j, const auto& request,
 }
 
 /// Create a HttpResponse with status 404 Not Found.
-static auto createNotFoundResponse(const std::string& errorMsg,
-                                   const HttpRequest auto& request) {
+CPP_template(typename RequestType)(
+    requires HttpRequest<
+        RequestType>) static auto createNotFoundResponse(const std::string&
+                                                             errorMsg,
+                                                         const RequestType&
+                                                             request) {
   return createHttpResponseFromString(errorMsg, http::status::not_found,
                                       request, MediaType::textPlain);
 }
 
 /// Create a HttpResponse with status 403 Forbidden.
-static auto createForbiddenResponse(const std::string& errorMsg,
-                                    const HttpRequest auto& request) {
+CPP_template(typename RequestType)(
+    requires HttpRequest<
+        RequestType>) static auto createForbiddenResponse(const std::string&
+                                                              errorMsg,
+                                                          const RequestType&
+                                                              request) {
   return createHttpResponseFromString(errorMsg, http::status::forbidden,
                                       request, MediaType::textPlain);
 }
 
 /// Create a HttpResponse with status 400 Bad Request.
-static auto createBadRequestResponse(std::string body,
-                                     const HttpRequest auto& request) {
+CPP_template(typename RequestType)(
+    requires HttpRequest<
+        RequestType>) static auto createBadRequestResponse(std::string body,
+                                                           const RequestType&
+                                                               request) {
   return createHttpResponseFromString(std::move(body),
                                       http::status::bad_request, request,
                                       MediaType::textPlain);
diff --git a/src/util/json.h b/src/util/json.h
index 7c3be8dd15..e4822d9a75 100644
--- a/src/util/json.h
+++ b/src/util/json.h
@@ -38,7 +38,7 @@ Convenience header for Nlohmann::Json that sets the default options. Also
 
 // For higher flexibility of the custom json helper functions.
 template <typename T>
-concept OrderedOrUnorderedJson =
+CPP_concept OrderedOrUnorderedJson =
     ad_utility::SameAsAny<T, nlohmann::json, nlohmann::ordered_json>;
 
 /*
@@ -49,8 +49,8 @@ concept OrderedOrUnorderedJson =
 @param jsonFileName Name of the file, or path to the file. Must describe a
 `.json` file.
 */
-template <OrderedOrUnorderedJson Json>
-Json fileToJson(std::string_view jsonFileName) {
+CPP_template(typename Json)(requires OrderedOrUnorderedJson<Json>) Json
+    fileToJson(std::string_view jsonFileName) {
   // Check, if the filename/-path ends with ".json". Checking, if it's a valid
   // file, is done by `ad_utility::makeIfstream`.
   if (!jsonFileName.ends_with(".json")) {
@@ -72,7 +72,8 @@ Json fileToJson(std::string_view jsonFileName) {
 @brief Returns the string representation of the type of the given
 `nlohmann::json`. Only supports official json types.
 */
-inline std::string jsonToTypeString(const OrderedOrUnorderedJson auto& j) {
+CPP_template(typename T)(requires OrderedOrUnorderedJson<T>) inline std::string
+    jsonToTypeString(const T& j) {
   if (j.is_array()) {
     return "array";
   } else if (j.is_boolean()) {
@@ -106,8 +107,9 @@ in such cases will always return a `std::optional`, that contains no value.
 namespace nlohmann {
 template <typename T>
 struct adl_serializer<std::optional<T>> {
-  static void to_json(OrderedOrUnorderedJson auto& j,
-                      const std::optional<T>& opt) {
+  CPP_template(typename S)(
+      requires OrderedOrUnorderedJson<
+          S>) static void to_json(S& j, const std::optional<T>& opt) {
     if (opt.has_value()) {
       j = opt.value();
     } else {
@@ -115,8 +117,9 @@ struct adl_serializer<std::optional<T>> {
     }
   }
 
-  static void from_json(const OrderedOrUnorderedJson auto& j,
-                        std::optional<T>& opt) {
+  CPP_template(typename S)(requires OrderedOrUnorderedJson<
+                           S>) static void from_json(const S& j,
+                                                     std::optional<T>& opt) {
     if (j.is_null()) {
       opt = std::nullopt;
     } else {
@@ -131,13 +134,16 @@ struct adl_serializer<std::optional<T>> {
 namespace nlohmann {
 template <>
 struct adl_serializer<std::monostate> {
-  static void to_json(OrderedOrUnorderedJson auto& j, const std::monostate&) {
+  CPP_template(typename S)(requires OrderedOrUnorderedJson<
+                           S>) static void to_json(S& j,
+                                                   const std::monostate&) {
     // Monostate is just an empty placeholder value.
     j = nullptr;
   }
 
-  static void from_json(const OrderedOrUnorderedJson auto& j,
-                        const std::monostate&) {
+  CPP_template(typename S)(requires OrderedOrUnorderedJson<
+                           S>) static void from_json(const S& j,
+                                                     const std::monostate&) {
     /*
     Monostate holds no values, so the given monostate is already identical to
     the serialized one.
@@ -169,8 +175,9 @@ Example: The serialized format for a `std::variant<int, float>` containing a
 namespace nlohmann {
 template <typename... Types>
 struct adl_serializer<std::variant<Types...>> {
-  static void to_json(OrderedOrUnorderedJson auto& j,
-                      const std::variant<Types...>& var) {
+  CPP_template(typename S)(
+      requires OrderedOrUnorderedJson<
+          S>) static void to_json(S& j, const std::variant<Types...>& var) {
     // We need to save, which of the types the std::variant actually
     // uses.
     j["index"] = var.index();
@@ -183,8 +190,9 @@ struct adl_serializer<std::variant<Types...>> {
     std::visit([&j](const auto& value) { j["value"] = value; }, var);
   }
 
-  static void from_json(const OrderedOrUnorderedJson auto& j,
-                        std::variant<Types...>& var) {
+  CPP_template(typename S)(
+      requires OrderedOrUnorderedJson<
+          S>) static void from_json(const S& j, std::variant<Types...>& var) {
     // Which of the `sizeof...(Types)` possible value types, was the
     // serialized std::variant using?
     size_t index = j["index"].template get<size_t>();
@@ -218,10 +226,11 @@ with the json object literal keys `index` and `value`.
 */
 namespace nlohmann {
 template <typename T>
-requires std::is_copy_constructible_v<T>
-struct adl_serializer<std::unique_ptr<T>> {
-  static void to_json(OrderedOrUnorderedJson auto& j,
-                      const std::unique_ptr<T>& ptr) {
+struct adl_serializer<std::unique_ptr<T>,
+                      std::enable_if_t<std::is_copy_constructible_v<T>>> {
+  CPP_template(typename S)(
+      requires OrderedOrUnorderedJson<
+          S>) static void to_json(S& j, const std::unique_ptr<T>& ptr) {
     // Does the `unique_ptr` hold anything? If yes, save the dereferenced
     // object, if no, save a `nullptr`.
     if (ptr) {
@@ -231,8 +240,9 @@ struct adl_serializer<std::unique_ptr<T>> {
     }
   }
 
-  static void from_json(const OrderedOrUnorderedJson auto& j,
-                        std::unique_ptr<T>& ptr) {
+  CPP_template(typename S)(requires OrderedOrUnorderedJson<
+                           S>) static void from_json(const S& j,
+                                                     std::unique_ptr<T>& ptr) {
     if (j.is_null()) {
       // If `json` is null, we just delete the content of ptr, because it
       // should be an empty `unique_ptr`.
diff --git a/src/util/stream_generator.h b/src/util/stream_generator.h
index 0a965751c0..8a0b24209c 100644
--- a/src/util/stream_generator.h
+++ b/src/util/stream_generator.h
@@ -74,8 +74,8 @@ class stream_generator_promise {
    * @return Whether or not the coroutine should get suspended (currently based
    * on isBufferLargeEnough()), wrapped inside a suspend_sometimes class.
    */
-  suspend_sometimes yield_value(
-      const ad_utility::Streamable auto& value) noexcept {
+  CPP_template(typename S)(requires ad_utility::Streamable<S>) suspend_sometimes
+      yield_value(const S& value) noexcept {
     // _stream appends its result to _value
     _stream << value;
     return suspend_sometimes{isBufferLargeEnough()};
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 904bd58706..d588e74e55 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -130,7 +130,7 @@ addLinkAndDiscoverTest(CryptographicHashUtilsTest util)
 
 addLinkAndDiscoverTest(CacheTest)
 
-addLinkAndDiscoverTest(ConcurrentCacheTest)
+addLinkAndDiscoverTestNoLibs(ConcurrentCacheTest)
 
 # This test also seems to use the same filenames and should be fixed.
 addLinkAndDiscoverTestSerial(FileTest)
@@ -225,7 +225,7 @@ addLinkAndDiscoverTestSerial(SparqlAntlrParserTest parser sparqlExpressions engi
 # TODO<qup42, joka921> fix this
 addLinkAndDiscoverTestSerial(SerializerTest)
 
-addLinkAndDiscoverTest(ParametersTest)
+addLinkAndDiscoverTestNoLibs(ParametersTest)
 
 addLinkAndDiscoverTest(ZstdCompressionTest zstd ${cmake_thread_libs_init})
 
@@ -233,7 +233,7 @@ addLinkAndDiscoverTest(TaskQueueTest)
 
 addLinkAndDiscoverTest(SetOfIntervalsTest sparqlExpressions)
 
-addLinkAndDiscoverTest(TypeTraitsTest)
+addLinkAndDiscoverTestNoLibs(TypeTraitsTest)
 
 addLinkAndDiscoverTestSerial(SparqlExpressionTest sparqlExpressions index engine)
 
@@ -245,7 +245,7 @@ addLinkAndDiscoverTest(AcceptHeaderTest mediaTypes httpParser)
 
 addLinkAndDiscoverTest(RdfEscapingTest parser)
 
-addLinkAndDiscoverTest(CompactStringVectorTest)
+addLinkAndDiscoverTestNoLibs(CompactStringVectorTest)
 
 addLinkAndDiscoverTest(SparqlDataTypesTest engine)
 
@@ -289,7 +289,7 @@ addLinkAndDiscoverTest(TripleComponentTest parser)
 
 addLinkAndDiscoverTest(ValueIdTest util)
 
-addLinkAndDiscoverTest(LambdaHelpersTest)
+addLinkAndDiscoverTestNoLibs(LambdaHelpersTest)
 
 addLinkAndDiscoverTest(ParseExceptionTest parser engine)
 
@@ -415,13 +415,13 @@ addLinkAndDiscoverTest(UpdateFetcherTest http)
 
 addLinkAndDiscoverTest(MessageSenderTest http)
 
-addLinkAndDiscoverTest(CancellationHandleTest util)
+addLinkAndDiscoverTestNoLibs(CancellationHandleTest util)
 
 addLinkAndDiscoverTest(ProgressBarTest util)
 
 addLinkAndDiscoverTest(CachingMemoryResourceTest)
 
-addLinkAndDiscoverTest(ParallelMultiwayMergeTest)
+addLinkAndDiscoverTestNoLibs(ParallelMultiwayMergeTest)
 
 addLinkAndDiscoverTest(ParseableDurationTest)
 
diff --git a/test/ConfigManagerTest.cpp b/test/ConfigManagerTest.cpp
index 315e02d7a3..4d9e5ee257 100644
--- a/test/ConfigManagerTest.cpp
+++ b/test/ConfigManagerTest.cpp
@@ -1727,10 +1727,12 @@ TEST(ConfigManagerTest, AddExceptionValidator) {
                                      std::string validatorExceptionMessage,
                                      ConfigManager& m,
                                      ConstConfigOptionProxy<Ts>... optProxy) {
+    auto exceptionalValidator =
+        generateDummyNonExceptionValidatorFunction<Ts...>(variant);
     m.addValidator(
-        transformValidatorIntoExceptionValidator<Ts...>(
-            generateDummyNonExceptionValidatorFunction<Ts...>(variant),
-            std::move(validatorExceptionMessage)),
+        transformValidatorIntoExceptionValidator<decltype(exceptionalValidator),
+                                                 Ts...>(
+            exceptionalValidator, std::move(validatorExceptionMessage)),
         "", optProxy...);
   });
 }
@@ -1999,16 +2001,17 @@ TEST(ConfigManagerTest, AddOptionNoExceptionValidator) {
 }
 
 TEST(ConfigManagerTest, AddOptionExceptionValidator) {
-  doAddOptionValidatorTest(
-      []<typename... Ts>(auto validatorFunction,
-                         std::string validatorExceptionMessage,
-                         ConfigManager& m, ConstConfigOptionProxy<Ts>... args) {
-        m.addOptionValidator(
-            transformValidatorIntoExceptionValidator<
-                decltype(args.getConfigOption())...>(
-                validatorFunction, std::move(validatorExceptionMessage)),
-            "", args...);
-      });
+  doAddOptionValidatorTest([]<typename... Ts>(
+                               auto validatorFunction,
+                               std::string validatorExceptionMessage,
+                               ConfigManager& m,
+                               ConstConfigOptionProxy<Ts>... args) {
+    m.addOptionValidator(
+        transformValidatorIntoExceptionValidator<
+            decltype(validatorFunction), decltype(args.getConfigOption())...>(
+            validatorFunction, std::move(validatorExceptionMessage)),
+        "", args...);
+  });
 }
 
 /*
@@ -2534,8 +2537,9 @@ TEST(ConfigManagerTest, PrintConfigurationDocComparison) {
   // Add a default validator to the given `ConfigManager`.
   auto addDefaultValidator =
       [](ConfigManager* configManager,
-         const ad_utility::isInstantiation<
-             ConstConfigOptionProxy> auto&... configOptionsToBeChecked) {
+         const QL_CONCEPT_OR_NOTHING(
+             ad_utility::isInstantiation<
+                 ConstConfigOptionProxy>) auto&... configOptionsToBeChecked) {
         const std::string validatorDescription = absl::StrCat(
             "Validator for configuration options ",
             ad_utility::lazyStrJoin(
diff --git a/test/ConstexprUtilsTest.cpp b/test/ConstexprUtilsTest.cpp
index 8ebfb024c5..e59f7d44f1 100644
--- a/test/ConstexprUtilsTest.cpp
+++ b/test/ConstexprUtilsTest.cpp
@@ -148,8 +148,7 @@ TEST(ConstexprUtils, RuntimeValueToCompileTimeValue) {
 
 // A helper struct for the following test.
 struct F1 {
-  template <int i>
-  requires(i == 0 || i == 1) int operator()() const {
+  CPP_template(int i)(requires(i == 0 || i == 1)) int operator()() const {
     return i + 1;
   }
 };
@@ -158,20 +157,20 @@ TEST(ConstexprUtils, ConstexprSwitch) {
   using namespace ad_utility;
   {
     auto f = []<int i> { return i * 2; };
-    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>(f, 2)), 4);
-    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>(f, 5)), 10);
-    ASSERT_ANY_THROW((ConstexprSwitch<1, 2, 3, 5>(f, 4)));
+    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>{}(f, 2)), 4);
+    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>{}(f, 5)), 10);
+    ASSERT_ANY_THROW((ConstexprSwitch<1, 2, 3, 5>{}(f, 4)));
   }
   {
     auto f = []<int i>(int j) { return i * j; };
-    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>(f, 2, 7)), 14);
-    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>(f, 5, 2)), 10);
-    ASSERT_ANY_THROW((ConstexprSwitch<1, 2, 3, 5>(f, 4, 3)));
+    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>{}(f, 2, 7)), 14);
+    ASSERT_EQ((ConstexprSwitch<1, 2, 3, 5>{}(f, 5, 2)), 10);
+    ASSERT_ANY_THROW((ConstexprSwitch<1, 2, 3, 5>{}(f, 4, 3)));
   }
 
   // F1 can only be called with 0 and 1 as template arguments.
-  static_assert(std::invocable<decltype(ConstexprSwitch<0, 1>), F1, int>);
-  static_assert(!std::invocable<decltype(ConstexprSwitch<0, 1, 2>), F1, int>);
+  static_assert(std::invocable<decltype(ConstexprSwitch<0, 1>{}), F1, int>);
+  static_assert(!std::invocable<decltype(ConstexprSwitch<0, 1, 2>{}), F1, int>);
 }
 
 /*
diff --git a/test/JsonUtilTest.cpp b/test/JsonUtilTest.cpp
index 024e4828d0..54454d3b1b 100644
--- a/test/JsonUtilTest.cpp
+++ b/test/JsonUtilTest.cpp
@@ -14,9 +14,12 @@
 /*
 @brief Do the `fileToJson` test with the wanted json class type.
 */
-template <OrderedOrUnorderedJson WantedJsonClassType>
-static void doFileToJsonTest(
-    ad_utility::source_location l = ad_utility::source_location::current()) {
+CPP_template(typename WantedJsonClassType)(
+    requires OrderedOrUnorderedJson<
+        WantedJsonClassType>) static void doFileToJsonTest(ad_utility::source_location
+                                                               l = ad_utility::
+                                                                   source_location::
+                                                                       current()) {
   // For generating better messages, when failing a test.
   auto trace{generateLocationTrace(l, "doFileToJsonTest")};
 
diff --git a/test/SerializerTest.cpp b/test/SerializerTest.cpp
index 5c10d4b0e8..4046031c02 100644
--- a/test/SerializerTest.cpp
+++ b/test/SerializerTest.cpp
@@ -61,12 +61,11 @@ class C {
   int b;
 
  public:
-  AD_SERIALIZE_FRIEND_FUNCTION(C);
+  AD_SERIALIZE_FRIEND_FUNCTION(C) {
+    serializer | arg.a;
+    serializer | arg.b;
+  }
 };
-AD_SERIALIZE_FUNCTION(C) {
-  serializer | arg.a;
-  serializer | arg.b;
-}
 
 // D is not serializable
 struct D {};
diff --git a/test/SparqlAntlrParserTest.cpp b/test/SparqlAntlrParserTest.cpp
index cca4ebeddb..8d87b3c2dd 100644
--- a/test/SparqlAntlrParserTest.cpp
+++ b/test/SparqlAntlrParserTest.cpp
@@ -1541,8 +1541,9 @@ auto idExpressionMatcher = [](Id id) {
 // (via `dynamic_cast`) to an object of the same type that a call to the
 // `makeFunction` yields. The matcher also checks that the expression's children
 // are the `variables`.
-auto matchNary(auto makeFunction,
-               ad_utility::SimilarTo<Variable> auto&&... variables)
+auto matchNary(
+    auto makeFunction,
+    QL_CONCEPT_OR_NOTHING(ad_utility::SimilarTo<Variable>) auto&&... variables)
     -> ::testing::Matcher<const sparqlExpression::SparqlExpression::Ptr&> {
   using namespace sparqlExpression;
   return matchNaryWithChildrenMatchers(makeFunction,
diff --git a/test/TypeTraitsTest.cpp b/test/TypeTraitsTest.cpp
index b1063be0a7..41d468d96f 100644
--- a/test/TypeTraitsTest.cpp
+++ b/test/TypeTraitsTest.cpp
@@ -363,3 +363,22 @@ TEST(TypeTraits, Rvalue) {
   static_assert(!Rvalue<const int&>);
   static_assert(!Rvalue<int&>);
 }
+
+// _____________________________________________________________________________
+TEST(TypeTraits, InvokeResultSfinaeFriendly) {
+  using namespace ad_utility;
+  using namespace ad_utility::invokeResultSfinaeFriendly::detail;
+  [[maybe_unused]] auto x = [](int) -> bool { return false; };
+
+  static_assert(
+      std::is_same_v<InvokeResultSfinaeFriendly<decltype(x), int>, bool>);
+  [[maybe_unused]] auto tp = getInvokeResultImpl<decltype(x), int>();
+  EXPECT_TRUE((std::is_same_v<typename decltype(tp)::type, bool>));
+
+  static_assert(
+      std::is_same_v<InvokeResultSfinaeFriendly<decltype(x), const char*>,
+                     InvalidInvokeResult<decltype(x), const char*>>);
+  [[maybe_unused]] auto tp2 = getInvokeResultImpl<decltype(x), const char*>();
+  EXPECT_TRUE((std::is_same_v<typename decltype(tp2)::type,
+                              InvalidInvokeResult<decltype(x), const char*>>));
+}
diff --git a/test/ValidatorTest.cpp b/test/ValidatorTest.cpp
index c6d74a3217..7607a19bd4 100644
--- a/test/ValidatorTest.cpp
+++ b/test/ValidatorTest.cpp
@@ -426,8 +426,9 @@ TEST(ConfigOptionValidatorManagerTest, ValidatorConstructor) {
 TEST(ValidatorConceptTest, TransformValidatorIntoExceptionValidator) {
   // Helper function, that check, if a given validator behaves as
   // wanted, before and after being transformed into an exception validator.
-  auto checkValidator = []<typename... ParameterTypes>(
-                            ValidatorFunction<ParameterTypes...> auto func,
+  auto checkValidator = []<typename ValidatorFunc, typename... ParameterTypes>(
+                            // ValidatorFunction<ParameterTypes...> auto func,
+                            ValidatorFunc func,
                             const std::tuple<ParameterTypes...>& validValues,
                             const std::tuple<ParameterTypes...>& nonValidValues,
                             ad_utility::source_location l =
@@ -440,7 +441,8 @@ TEST(ValidatorConceptTest, TransformValidatorIntoExceptionValidator) {
 
     // Transform and check.
     auto transformedFunc =
-        transformValidatorIntoExceptionValidator<ParameterTypes...>(func,
+        transformValidatorIntoExceptionValidator<ValidatorFunc,
+                                                 ParameterTypes...>(func,
                                                                     "test");
     static_assert(ExceptionValidatorFunction<decltype(transformedFunc),
                                              ParameterTypes...>);
diff --git a/test/backports/CMakeLists.txt b/test/backports/CMakeLists.txt
index 3e3f2e9865..aef714c8b2 100644
--- a/test/backports/CMakeLists.txt
+++ b/test/backports/CMakeLists.txt
@@ -3,4 +3,5 @@ add_executable(AlgorithmBackportTests algorithmTest.cpp)
 add_executable(DebugJoinView DebugJoinView.cpp)
 qlever_target_link_libraries(DebugJoinView)
 target_link_libraries(AlgorithmBackportTests GTest::gtest GTest::gmock_main)
-gtest_discover_tests(AlgorithmBackportTests AlgorithmBackportTests)
\ No newline at end of file
+gtest_discover_tests(AlgorithmBackportTests AlgorithmBackportTests)
+addLinkAndDiscoverTestNoLibs(ConceptsTest)
diff --git a/test/backports/ConceptsTest.cpp b/test/backports/ConceptsTest.cpp
new file mode 100644
index 0000000000..5452e3a046
--- /dev/null
+++ b/test/backports/ConceptsTest.cpp
@@ -0,0 +1,41 @@
+//
+// Created by kalmbacj on 2/10/25.
+//
+
+#include <gmock/gmock.h>
+
+#include "backports/concepts.h"
+
+template <typename... T>
+CPP_concept Something = (... && (sizeof(T) <= 4));
+
+// A templated class with a variety of members.
+CPP_template(typename T)(requires(Something<T>)) struct C {
+  // A constructor that takes an int only exists for certain `T`
+  explicit constexpr CPP_ctor(C)([[maybe_unused]] int i)(
+      requires Something<T>) {}
+
+  // A member function that is templated and constrained on an independent
+  // type `F`.
+  CPP_template_2(typename F)(requires Something<F>) void f(F arg) { (void)arg; }
+
+  // Same, but the constraint combines F and T. Note that you have to use
+  // `CPP_and_2` instead of `CPP_and`.
+  CPP_template_2(typename F)(
+      requires Something<F> CPP_and_2 Something<T>) auto i() {
+  }  // Additional template parameter + `auto`
+
+  // Member function with explicit return type that has no other template
+  // arguments but poses additional constraints on `T`.
+  CPP_member auto g() -> CPP_ret(void)(requires Something<T>) {
+  }  // only exists for some `T`
+
+  // Member function with `auto` return type that has no other template
+  // arguments but poses additional constraints on `T`.
+  CPP_auto_member auto CPP_fun(h)()(requires Something<T>) {}
+};
+
+// A variadic function template.  NOTE: you currently have to use plain `&&`,
+// the `CPP_and...` macros won't work here.
+CPP_variadic_template(typename... Ts)(
+    requires(Something<Ts...>&& Something<Ts...>)) void f(Ts...) {}
diff --git a/test/util/BenchmarkMeasurementContainerHelpers.cpp b/test/util/BenchmarkMeasurementContainerHelpers.cpp
index ecb9c8a51e..9bc67b9e2f 100644
--- a/test/util/BenchmarkMeasurementContainerHelpers.cpp
+++ b/test/util/BenchmarkMeasurementContainerHelpers.cpp
@@ -10,9 +10,9 @@
 using namespace std::string_literals;
 
 // ____________________________________________________________________________
-template <
-    ad_utility::SimilarToAnyTypeIn<ad_benchmark::ResultTable::EntryType> Type>
-Type createDummyValueEntryType() {
+CPP_template_def(typename Type)(requires ad_utility::SimilarToAnyTypeIn<
+                                Type, ad_benchmark::ResultTable::EntryType>)
+    Type createDummyValueEntryType() {
   if constexpr (ad_utility::isSimilar<Type, float>) {
     return 4.2f;
   } else if constexpr (ad_utility::isSimilar<Type, std::string>) {
diff --git a/test/util/BenchmarkMeasurementContainerHelpers.h b/test/util/BenchmarkMeasurementContainerHelpers.h
index 86c38ca6c1..46b27cc79d 100644
--- a/test/util/BenchmarkMeasurementContainerHelpers.h
+++ b/test/util/BenchmarkMeasurementContainerHelpers.h
@@ -17,9 +17,9 @@
 @brief Generate a dummy value of the given type. Used for generating test values
 for `ad_benchmark::ResultTable`.
 */
-template <
-    ad_utility::SimilarToAnyTypeIn<ad_benchmark::ResultTable::EntryType> Type>
-Type createDummyValueEntryType();
+CPP_template(typename Type)(requires ad_utility::SimilarToAnyTypeIn<
+                            Type, ad_benchmark::ResultTable::EntryType>) Type
+    createDummyValueEntryType();
 
 /*
 @brief Call the lambda with each of the alternatives in
diff --git a/test/util/IdTableHelpers.h b/test/util/IdTableHelpers.h
index 1117f3090f..c831c12564 100644
--- a/test/util/IdTableHelpers.h
+++ b/test/util/IdTableHelpers.h
@@ -106,7 +106,8 @@ struct MatchesIdTable {
   }
 
   // Overload for lvalue-references (`IdTable`s are not copyable)
-  template <ad_utility::SimilarTo<IdTable> T>
+  template <typename T,
+            typename = std::enable_if_t<ad_utility::SimilarTo<T, IdTable>>>
   auto operator()(T& table) const {
     // Note: We could use `Eq(cref(table))` , but the explicit deep copy
     // gets rid of all possibly lifetime and mutability issues.
diff --git a/test/util/ValidatorHelpers.cpp b/test/util/ValidatorHelpers.cpp
index 49b58c6b06..6a782a725f 100644
--- a/test/util/ValidatorHelpers.cpp
+++ b/test/util/ValidatorHelpers.cpp
@@ -8,9 +8,9 @@
 #include "util/TypeTraits.h"
 
 // ____________________________________________________________________________
-template <
-    ad_utility::SameAsAnyTypeIn<ad_utility::ConfigOption::AvailableTypes> Type>
-Type createDummyValueForValidator(size_t variant) {
+CPP_template_def(typename Type)(requires ad_utility::SameAsAnyTypeIn<
+                                Type, ad_utility::ConfigOption::AvailableTypes>)
+    Type createDummyValueForValidator(size_t variant) {
   if constexpr (std::is_same_v<Type, bool>) {
     return variant % 2;
   } else if constexpr (std::is_same_v<Type, std::string>) {
diff --git a/test/util/ValidatorHelpers.h b/test/util/ValidatorHelpers.h
index f5827c9bfa..9a3606a908 100644
--- a/test/util/ValidatorHelpers.h
+++ b/test/util/ValidatorHelpers.h
@@ -18,9 +18,9 @@ cooperation with `generateSingleParameterValidatorFunction`, while keeping the
 invariant of `generateValidatorFunction` true.
 `variant` slightly changes the returned value.
 */
-template <
-    ad_utility::SameAsAnyTypeIn<ad_utility::ConfigOption::AvailableTypes> Type>
-Type createDummyValueForValidator(size_t variant);
+CPP_template(typename Type)(requires ad_utility::SameAsAnyTypeIn<
+                            Type, ad_utility::ConfigOption::AvailableTypes>)
+    Type createDummyValueForValidator(size_t variant);
 
 /*
 @brief For easily creating `Validator` functions, that compare given values to