Split up the evaluation helpers into specific files.

Utility/enroll.h

@@ -0,0 +1,84 @@
+static_assert( __cplusplus > 2020'99 );
+
+#pragma once
+
+#include <Alepha/Alepha.h>
+
+#include <tuple>
+#include <utility>
+
+namespace Alepha::Hydrogen::Utility  ::detail::  enroll_m
+{
+	inline namespace exports
+	{
+		/*!
+		 * Mechanism to define initializer blocks.
+		 *
+		 * C++ does not have initializer blocks, but it does have the ability to define variables that are set to
+		 * values before `main` is invoked.  It is possible to use constructors or functions to leverage this fact
+		 * and make blocks of code that run before main:
+		 *
+		 * ```
+		 * struct MyThing
+		 * {
+		 *	MyThing()
+		 *	{
+		 *		std::cout << "Hello World, before main!" << std::endl;
+		 *	}
+		 * } beforeMain;
+		 * ```
+		 *
+		 * The above code works such that, as a side-effect of the construction of `beforeMain`, the desired code is
+		 * run.  However, it is rather cumbersome.  There are ways of simplifying this:
+		 *
+		 * ```
+		 * int beforeMainFunction() { std::cout << "Hello World, before main!" << std::endl; return 42; }
+		 * const int beforeMain= beforeMainFunction();
+		 * ```
+		 *
+		 * While this is a bit less confusing, there's still a need to define a function and return a dummy
+		 * variable.  Lambdas with immediate invocation syntax (see `evaluate`) can make this nicer still:
+		 *
+		 * ```
+		 * const int beforeMain= evaluate <=[] { std::cout << "Hello World, before main!" << std::endl; return 0; };
+		 * ```
+		 *
+		 * That is a bit better, but that pesky dummy value is still there.  The fact that this is an int is going
+		 * to be a potential source of confusion.  Instead, we want to keep the reader focused on the fact that code
+		 * is being run, and disguise the fact that there's a variable involved.
+		 *
+		 * `enroll` creates a hook by which the above techniques can be made more clear that it one is running
+		 * pre-main code.
+		 *
+		 * ```
+		 * auto myInitBlock= enroll <=[]
+		 * {
+		 * 	std::cout << "Hello World, before main!" << std::endl;
+		 * };
+		 * ```
+		 *
+		 * Because `enroll <=` precedes the lambda definition it is quite clear that something else is going on
+		 * here.  The `<=` in this case should be thought of as a `fat left arrow` -- the lambda is being given
+		 * to `enroll` to be used as an initializer block.
+		 */
+		inline struct enroll_t {} enroll;
+	}
+
+	template< typename Function >
+	struct registration
+	{
+		explicit registration( Function f ) { f(); }
+	};
+
+	template< typename Function >
+	constexpr auto
+	operator <=( enroll_t, Function &&func ) noexcept
+	{
+		return registration{ std::forward< Function >( func ) };
+	}
+}
+
+namespace Alepha::Hydrogen::Utility::inline exports::inline enroll_m
+{
+	using namespace detail::enroll_m::exports;
+}