[WIP] upgrade to C++20 features (concepts, etc.)

Author: toroidal-code

.gitignore

@@ -1 +1 @@
-build
+build*

.vscode/settings.json

@@ -3,6 +3,76 @@
     "*.scons": "python",
     "regex": "cpp",
     "xutility": "cpp",
-    "optional": "cpp"
+    "optional": "cpp",
+    "iosfwd": "cpp",
+    "type_traits": "cpp",
+    "functional": "cpp",
+    "algorithm": "cpp",
+    "complex": "cpp",
+    "system_error": "cpp",
+    "xlocmon": "cpp",
+    "xtr1common": "cpp",
+    "array": "cpp",
+    "atomic": "cpp",
+    "bit": "cpp",
+    "cctype": "cpp",
+    "charconv": "cpp",
+    "clocale": "cpp",
+    "cmath": "cpp",
+    "compare": "cpp",
+    "concepts": "cpp",
+    "cstddef": "cpp",
+    "cstdint": "cpp",
+    "cstdio": "cpp",
+    "cstdlib": "cpp",
+    "cstring": "cpp",
+    "ctime": "cpp",
+    "cwchar": "cpp",
+    "deque": "cpp",
+    "exception": "cpp",
+    "format": "cpp",
+    "forward_list": "cpp",
+    "initializer_list": "cpp",
+    "ios": "cpp",
+    "iostream": "cpp",
+    "istream": "cpp",
+    "iterator": "cpp",
+    "limits": "cpp",
+    "list": "cpp",
+    "locale": "cpp",
+    "memory": "cpp",
+    "mutex": "cpp",
+    "new": "cpp",
+    "ostream": "cpp",
+    "queue": "cpp",
+    "ranges": "cpp",
+    "ratio": "cpp",
+    "set": "cpp",
+    "span": "cpp",
+    "sstream": "cpp",
+    "stdexcept": "cpp",
+    "stop_token": "cpp",
+    "streambuf": "cpp",
+    "string": "cpp",
+    "thread": "cpp",
+    "tuple": "cpp",
+    "typeinfo": "cpp",
+    "unordered_map": "cpp",
+    "unordered_set": "cpp",
+    "utility": "cpp",
+    "valarray": "cpp",
+    "vector": "cpp",
+    "xfacet": "cpp",
+    "xhash": "cpp",
+    "xiosbase": "cpp",
+    "xlocale": "cpp",
+    "xlocbuf": "cpp",
+    "xlocinfo": "cpp",
+    "xlocmes": "cpp",
+    "xlocnum": "cpp",
+    "xloctime": "cpp",
+    "xmemory": "cpp",
+    "xstring": "cpp",
+    "xtree": "cpp"
   }
 }

CMakeLists.txt

@@ -18,7 +18,7 @@ target_precompile_headers(c++spec INTERFACE
   ${c++spec_headers}
 )
 
-option(BUILD_TESTS "Build tests." OFF)
+option(BUILD_TESTS "Build tests." ON)
 
 if(BUILD_TESTS)
   # enable_testing()
@@ -27,7 +27,7 @@ if(BUILD_TESTS)
   add_subdirectory(spec)
 endif(BUILD_TESTS)
 
-option(BUILD_EXAMPLES "Build examples." OFF)
+option(BUILD_EXAMPLES "Build examples." ON)
 
 if(BUILD_EXAMPLES)
   add_subdirectory(examples)

include/expectations/expectation.hpp

@@ -480,10 +480,8 @@ class ExpectationValue : public Expectation<A> {
   }
 };
 
-template <typename F>
+template <Util::is_functional F>
 class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
-  static_assert(Util::is_functional<F>::value,
-                "Error! ExpectationFunc can only contaion lambdas.");
 
   typedef decltype(std::declval<F>()()) block_ret_t;
   F block;
@@ -549,7 +547,7 @@ class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
   Result to_throw(std::string msg = "");
 };
 
-template <typename F>
+template <Util::is_functional F>
 template <typename Ex>
 Result ExpectationFunc<F>::to_throw(std::string msg) {
   Matchers::Throw<decltype(this->block.operator()()), Ex> matcher(*this);

include/it.hpp

@@ -5,6 +5,7 @@
 
 #include <string>
 #include <vector>
+
 #include "expectations/expectation.hpp"
 
 namespace CppSpec {
@@ -123,17 +124,13 @@ class ItCD : public ItBase {
  *   expect([] -> int { return 4; })
  * @endcode
  */
-template <class T>
-typename std::enable_if<not Util::is_functional<T>::value,
-                        ExpectationValue<T>>::type
-ItBase::expect(T value) {
+template <Util::is_not_functional T>
+ExpectationValue<T> ItBase::expect(T value) {
   return ExpectationValue<T>(*this, value);
 }
 
-template <typename T>
-auto ItBase::expect(T block) ->
-    typename std::enable_if<Util::is_functional<T>::value,
-                            ExpectationFunc<T>>::type {
+template <Util::is_functional T>
+ExpectationFunc<T> ItBase::expect(T block) {
   return ExpectationFunc<T>(*this, block);
 }
 
@@ -149,7 +146,7 @@ ExpectationValue<T> ItBase::expect(Let<T> &let) {
  *   expect({1,2,3})
  * @endcode
  */
-template <class T>
+template <typename T>
 ExpectationValue<std::initializer_list<T>> ItBase::expect(
     std::initializer_list<T> init_list) {
   return ExpectationValue<std::initializer_list<T>>(*this, init_list);

include/it_base.hpp

@@ -5,15 +5,16 @@
 
 #include <string>
 #include <vector>
-#include "runnable.hpp"
+
 #include "let.hpp"
+#include "runnable.hpp"
 #include "util.hpp"
 
 namespace CppSpec {
 
 template <typename T>
 class ExpectationValue;
-template <typename T>
+template <Util::is_functional T>
 class ExpectationFunc;
 
 /**
@@ -34,8 +35,8 @@ class ItBase : public Runnable {
   ItBase() = delete;  // Don't allow a default constructor
 
   /** @brief Copy constructor */
-  ItBase(const ItBase &copy) noexcept : Runnable(copy),
-                                        description(copy.description) {}
+  ItBase(const ItBase &copy) noexcept
+      : Runnable(copy), description(copy.description) {}
 
   /**
    * @brief Create an BaseIt without an explicit description
@@ -49,8 +50,7 @@ class ItBase : public Runnable {
    * @return the constructed BaseIt
    */
   explicit ItBase(const Child &parent, std::string description) noexcept
-      : Runnable(parent),
-        description(description) {}
+      : Runnable(parent), description(description) {}
 
   /**
    * @brief Get whether the object needs a description string
@@ -85,10 +85,8 @@ class ItBase : public Runnable {
    *
    * @return a ExpectationValue object containing the given value.
    */
-  template <typename T>
-  typename std::enable_if<not Util::is_functional<T>::value,
-                          ExpectationValue<T>>::type
-  expect(T value);
+  template <Util::is_not_functional T>
+  ExpectationValue<T> expect(T value);
 
   /**
    * @brief The `expect` object generator for lambdas
@@ -99,10 +97,8 @@ class ItBase : public Runnable {
    *
    * @return a ExpectationFunc object containing the given value.
    */
-  template <typename T>
-  typename std::enable_if<Util::is_functional<T>::value,
-                          ExpectationFunc<T>>::type
-  expect(T block);
+  template <Util::is_functional T>
+  ExpectationFunc<T> expect(T block);
 
   /**
    * @brief The `expect` object generator for initializer lists

include/matchers/contain.hpp

@@ -20,14 +20,14 @@ class ContainBase : public MatcherBase<A, E> {
   virtual std::string failure_message_when_negated() override;
   virtual bool diffable() { return true; }
 
- protected:
-  bool actual_collection_includes(U expected_item);
-  ContainBase(Expectation<A> &expectation,
-              std::initializer_list<U> expected)
+  ContainBase(Expectation<A> &expectation, std::initializer_list<U> expected)
       : MatcherBase<A, std::vector<U>>(expectation, std::vector<U>(expected)),
         actual(this->get_actual()){};
   ContainBase(Expectation<A> &expectation, U expected)
       : MatcherBase<A, U>(expectation, expected), actual(this->get_actual()){};
+
+ protected:
+  bool actual_collection_includes(U expected_item);
 };
 
 template <typename A, typename E, typename U>
@@ -53,7 +53,7 @@ bool ContainBase<A, E, U>::actual_collection_includes(U expected_item) {
   auto actual = this->get_actual();
   auto last = *(actual.begin());
   static_assert(
-      Util::verbose_assert<std::is_same<decltype(last), U>>::value,
+      Util::verbose_assert<std::is_same_v<decltype(last), U>>::value,
       "Expected item is not the same type as what is inside container.");
   return std::find(actual.begin(), actual.end(), expected_item) != actual.end();
 }
@@ -69,9 +69,7 @@ class Contain : public ContainBase<A, E, U> {
  public:
   bool match() override;
   bool negated_match() override;
-  Contain(Expectation<A> &expectation,
-          std::initializer_list<U> expected)
-      : ContainBase<A, E, U>(expectation, expected){};
+  using ContainBase<A, E, U>::ContainBase;
 
  protected:
   bool perform_match(Predicate predicate, Predicate hash_subset_predicate);
@@ -138,6 +136,6 @@ bool Contain<A, U, U>::match() {
   return this->actual_collection_includes(this->get_expected());
 }
 
-}  // ::Matchers
+}  // namespace Matchers
 }  // namespace CppSpec
 #endif  // CPPSPEC_MATCHERS_INCLUDE_HPP

include/matchers/end_with.hpp

@@ -4,17 +4,14 @@
 #pragma once
 
 #include <string>
+#include <ranges>
 #include "matcher_base.hpp"
 
 namespace CppSpec {
 namespace Matchers {
 
-template <typename A, typename E>
+template <std::ranges::range A, std::ranges::range E>
 class EndWith : public MatcherBase<A, E> {
-  static_assert(Util::is_iterable<A>::value && Util::is_iterable<E>::value,
-                "Error! Trying to match starting items with a non-iterable "
-                    "container");
-
  public:
  EndWith(Expectation <A> &expectation, E start)
      : MatcherBase<A, E>(expectation, start) { }

include/matchers/pretty_matchers.hpp

@@ -33,15 +33,11 @@ struct Pretty {
   static std::string last(const std::string &s, const char delim);
   static std::string improve_hash_formatting(std::string inspect_string);
 
-  template <typename T>
-  static
-      typename std::enable_if<Util::is_streamable<T>::value, std::string>::type
-      to_word(T &item);
+  template <Util::is_streamable T>
+  static std::string to_word(T &item);
 
   template <typename T>
-  static
-      typename std::enable_if<!Util::is_streamable<T>::value, std::string>::type
-      to_word(T &item);
+  static std::string to_word(T &item);
 
   template <typename T>
   static std::string to_word_type(T &item);
@@ -120,9 +116,8 @@ inline std::string Pretty::to_sentance(T &item) {
  *
  * @return the string representation
  */
-template <typename T>
-typename std::enable_if<Util::is_streamable<T>::value,
-                        std::string>::type inline Pretty::to_word(T &item) {
+template <Util::is_streamable T>
+inline std::string Pretty::to_word(T &item) {
   std::stringstream ss;
   ss << item;
   return ss.str();
@@ -151,8 +146,7 @@ inline std::string Pretty::to_word<std::false_type>(std::false_type &item) {
  * @return the string representation
  */
 template <typename T>
-typename std::enable_if<!Util::is_streamable<T>::value,
-                        std::string>::type inline Pretty::to_word(T &item) {
+inline std::string Pretty::to_word(T &item) {
   std::stringstream ss;
   // Ruby-style inspect for objects without an overloaded operator<<
   ss << "#<" << Util::demangle(typeid(item).name()) << ":" << &item << ">";
@@ -183,7 +177,7 @@ inline std::string Pretty::to_word(Matchers::MatcherBase<A, E> &matcher) {
 template <typename T>
 inline std::string Pretty::to_word_type(T &item) {
   std::string word = to_word(item);
-  if (Util::is_streamable<T>::value) {
+  if constexpr (Util::is_streamable<T>) {
     word += " : " + Util::demangle(typeid(T).name());
   }
   return word;

include/matchers/start_with.hpp

@@ -4,16 +4,14 @@
 #pragma once
 
 #include <string>
+#include <ranges>
 #include "matcher_base.hpp"
 
 namespace CppSpec {
 namespace Matchers {
 
-template <typename A, typename E>
+template <std::ranges::range A, std::ranges::range E>
 class StartWith : public MatcherBase<A, E> {
-  static_assert(Util::is_iterable<A>::value && Util::is_iterable<E>::value,
-                "Error! Trying to match starting items with a non-iterable "
-                    "container");
 
  public:
   StartWith(Expectation <A> &expectation, E start)