add nihil.std

159 files changed, 3305 insertions, 4311 deletions

diff --git a/.clang-format b/.clang-format
index ff932d0..b1f8727 100644
--- a/.clang-format
+++ b/.clang-format
@@ -23,6 +23,7 @@ PenaltyReturnTypeOnItsOwnLine: 0
 BreakTemplateDeclarations: Yes
 
 ForEachMacros:
+  - SECTION
   - GIVEN
   - AND_GIVEN
   - THEN
@@ -51,3 +52,13 @@ BraceWrapping:
 NamespaceIndentation: None
 FixNamespaceComments: true
 #WrapNamespaceBodyWithEmptyLines: Always
+
+AlignArrayOfStructures: Left
+AlignConsecutiveBitFields: true
+AlignConsecutiveDeclarations: Consecutive
+AlignConsecutiveMacros: Consecutive
+AlignConsecutiveShortCaseStatements:
+  Enabled: true
+AlignEscapedNewlines: LeftWithLastLine
+AlignOperands: AlignAfterOperator
+BreakBeforeBinaryOperators: None
diff --git a/.clang-tidy b/.clang-tidy
index 76636f6..c8d47b0 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -7,6 +7,7 @@ Checks: >
     -bugprone-reserved-identifier,
     -bugprone-easily-swappable-parameters,
   cert-*,
+    -cert-dcl58-cpp,
   concurrency-*,
   cppcoreguidelines-*,
     -cppcoreguidelines-avoid-do-while,
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cf42b4b..32a8f81 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,11 +41,15 @@ add_compile_options(-Wextra)
 add_compile_options(-Werror)
 add_compile_options(-Wpedantic)
 
+# Enable libc++ hardening
+add_compile_definitions(-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE)
+
 if(NIHIL_TESTS)
 	add_subdirectory(contrib/catch2)
 	enable_testing()
 endif()
 
+add_subdirectory(nihil.std)
 add_subdirectory(nihil.cli)
 add_subdirectory(nihil.core)
 add_subdirectory(nihil.error)
diff --git a/nihil.cli/CMakeLists.txt b/nihil.cli/CMakeLists.txt
index 78e9ff1..9f20cf7 100644
--- a/nihil.cli/CMakeLists.txt
+++ b/nihil.cli/CMakeLists.txt
@@ -1,7 +1,7 @@
 # This source code is released into the public domain.
 
 add_library(nihil.cli STATIC)
-target_link_libraries(nihil.cli PRIVATE nihil.util)
+target_link_libraries(nihil.cli PRIVATE nihil.std nihil.util)
 target_sources(nihil.cli
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	nihil.cli.ccm
diff --git a/nihil.cli/command.cc b/nihil.cli/command.cc
index 725b4eb..6271cc6 100644
--- a/nihil.cli/command.cc
+++ b/nihil.cli/command.cc
@@ -1,15 +1,6 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <expected>
-#include <functional>
-#include <iostream>
-#include <print>
-#include <string>
-
 // For EX_USAGE.  While <sysexits.h> is deprecated, there's no other standard
 // exit code for 'usage error'; some programs use 2 (common on Linux), but
 // 2 is also used for many other exit codes.
@@ -17,6 +8,7 @@ module;
 
 module nihil.cli;
 
+import nihil.std;
 import nihil.error;
 import :registry;
 
diff --git a/nihil.cli/command.ccm b/nihil.cli/command.ccm
index 74ef030..da3444a 100644
--- a/nihil.cli/command.ccm
+++ b/nihil.cli/command.ccm
@@ -4,13 +4,10 @@
 
 module;
 
-#include <expected>
-#include <functional>
-#include <string>
-
 export module nihil.cli:command;
 
 import nihil.error;
+import nihil.std;
 import :command_node;
 
 namespace nihil {
@@ -40,7 +37,6 @@ export struct command final : command_node {
 		-> std::expected<int, error> override;
 
 private:
-	std::string_view	m_path;
 	std::string_view	m_usage;
 	command_function_t	m_handler;
 };
diff --git a/nihil.cli/command_node.cc b/nihil.cli/command_node.cc
index dd18716..5936b8c 100644
--- a/nihil.cli/command_node.cc
+++ b/nihil.cli/command_node.cc
@@ -1,18 +1,11 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <expected>
-#include <iostream>
-#include <print>
-#include <string>
-
-#include <unistd.h>
+#include <unistd.h> // _exit
 
 module nihil.cli;
 
+import nihil.std;
 import nihil.core;
 import nihil.error;
 
@@ -23,14 +16,12 @@ command_node::command_node(std::string_view path) noexcept
 try	: m_path(path)
 {
 } catch (std::exception const &exc) {
-	std::fprintf(stderr, "%s\n", exc.what());
+	std::print(std::cerr, "%s\n", exc.what());
 	_exit(1);
 	/*NOTREACHED*/
 }
 
-command_node::~command_node()
-{
-}
+command_node::~command_node() = default;
 
 auto command_node::path(this command_node const &self) noexcept
 	-> std::string_view
diff --git a/nihil.cli/command_node.ccm b/nihil.cli/command_node.ccm
index 546eb46..25b5006 100644
--- a/nihil.cli/command_node.ccm
+++ b/nihil.cli/command_node.ccm
@@ -1,18 +1,9 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-/*
- * command_node represents a possibly-invocable command.
- */
-
-#include <expected>
-#include <string>
-
+// This source code is released into the public domain.
 export module nihil.cli:command_node;
 
+// command_node represents a possibly-invocable command.
+
+import nihil.std;
 import nihil.error;
 
 namespace nihil {
diff --git a/nihil.cli/command_tree.cc b/nihil.cli/command_tree.cc
index 2d14669..a77131a 100644
--- a/nihil.cli/command_tree.cc
+++ b/nihil.cli/command_tree.cc
@@ -1,18 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <iostream>
-#include <memory>
-#include <print>
-#include <ranges>
-#include <string>
-#include <vector>
-
+// This source code is released into the public domain.
 module nihil.cli;
 
+import nihil.std;
+
 namespace nihil {
 
 command_tree_node::command_tree_node()
@@ -64,7 +54,7 @@ auto command_tree_node::get_or_create_child(this command_tree_node &self,
 	-> command_tree_node *
 {
 	// Return the existing child, if there is one.
-	if (auto ptr = self.get_child(child); ptr != nullptr)
+	if (auto *ptr = self.get_child(child); ptr != nullptr)
 		return ptr;
 
 	// Insert a new child.
@@ -135,11 +125,11 @@ auto command_tree::insert(this command_tree &self,
 auto command_tree::find(this command_tree const &self, int &argc, char **&argv)
 	-> command_tree_node const *
 {
-	auto *this_node = &self.m_root_node;
+	auto const *this_node = &self.m_root_node;
 
 	// Iterate until we don't find a child command, then return that node.
 	while (argv[0] != nullptr) {
-		auto *next_node = this_node->get_child(argv[0]);
+		auto const *next_node = this_node->get_child(argv[0]);
 
 		if (next_node == nullptr)
 			return this_node;
diff --git a/nihil.cli/command_tree.ccm b/nihil.cli/command_tree.ccm
index 7297af7..84e4a0d 100644
--- a/nihil.cli/command_tree.ccm
+++ b/nihil.cli/command_tree.ccm
@@ -1,17 +1,7 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <map>
-#include <memory>
-#include <optional>
-#include <ranges>
-#include <vector>
-
+// This source code is released into the public domain.
 export module nihil.cli:command_tree;
 
+import nihil.std;
 import :command;
 
 namespace nihil {
diff --git a/nihil.cli/dispatch_command.cc b/nihil.cli/dispatch_command.cc
index 736e16e..7b4cf39 100644
--- a/nihil.cli/dispatch_command.cc
+++ b/nihil.cli/dispatch_command.cc
@@ -1,22 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <cstdio>
-#include <functional>
-#include <iostream>
-#include <map>
-#include <print>
-#include <ranges>
-#include <string>
-#include <utility>
-
-#include <unistd.h>
+#include <stdlib.h> // getprogname, NOLINT
+#include <unistd.h> // getopt
 
 module nihil.cli;
 
+import nihil.std;
 import nihil.core;
 
 namespace nihil {
@@ -45,7 +35,7 @@ auto dispatch_command(int argc, char **argv) -> int
 	 * Set the program name to the existing progname plus the full path
 	 * to the command being invoked; this makes error messages nicer.
 	 */
-	auto *old_progname = ::getprogname();
+	auto const *old_progname = ::getprogname();
 
 	{
 		auto cprogname = std::format("{} {}", ::getprogname(),
diff --git a/nihil.cli/dispatch_command.ccm b/nihil.cli/dispatch_command.ccm
index 1ba55bb..de94714 100644
--- a/nihil.cli/dispatch_command.ccm
+++ b/nihil.cli/dispatch_command.ccm
@@ -1,31 +1,14 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <functional>
-#include <iostream>
-#include <map>
-#include <string>
-#include <utility>
-
+// This source code is released into the public domain.
 export module nihil.cli:dispatch_command;
 
-import nihil.util;
-import :command;
-import :usage_error;
-
 namespace nihil {
 
-/*
- * Invoke a command (which must have been previously registered) using
- * the provided argument vector.
- *
- * The caller should have already stripped the executable name from argv[0]
- * so that the vector starts with the command name.  This is implicitly
- * done if main() uses getopt().
- */
+// Invoke a command (which must have been previously registered) using
+// the provided argument vector.
+//
+// The caller should have already stripped the executable name from argv[0]
+// so that the vector starts with the command name.  This is implicitly
+// done if main() uses getopt().
 export [[nodiscard]] auto dispatch_command(int argc, char **argv) -> int;
 
 } // namespace nihil
diff --git a/nihil.cli/registry.cc b/nihil.cli/registry.cc
index e35078d..0f0041b 100644
--- a/nihil.cli/registry.cc
+++ b/nihil.cli/registry.cc
@@ -1,16 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <cstdio>
-#include <exception>
-#include <memory>
-#include <vector>
-
+// This source code is released into the public domain.
 module nihil.cli;
 
+import nihil.std;
+
 namespace nihil {
 
 /*
@@ -22,11 +14,11 @@ try {
 	static auto commands = std::vector<std::shared_ptr<command_node>>();
 	return commands;
 } catch (std::exception const &exc) {
-	std::printf("%s\n", exc.what());
-	std::exit(1);
+	std::println(std::cerr, "{}", exc.what());
+	std::exit(1); // NOLINT
 } catch (...) {
-	std::printf("get_registered_commands(): unknown error\n");
-	std::exit(1);
+	std::println(std::cerr, "get_registered_commands(): unknown error\n");
+	std::exit(1); // NOLINT
 }
 
 /*
@@ -39,11 +31,11 @@ try {
 	auto &commands = get_registry();
 	commands.emplace_back(cmd, null_deleter);
 } catch (std::exception const &exc) {
-	std::printf("%s\n", exc.what());
-	std::exit(1);
+	std::println(std::cerr, "{}", exc.what());
+	std::exit(1); // NOLINT
 } catch (...) {
-	std::printf("get_registered_commands(): unknown error\n");
-	std::exit(1);
+	std::println(std::cerr, "get_registered_commands(): unknown error\n");
+	std::exit(1); // NOLINT
 }
 
 /*
diff --git a/nihil.cli/registry.ccm b/nihil.cli/registry.ccm
index 0b9754d..673f516 100644
--- a/nihil.cli/registry.ccm
+++ b/nihil.cli/registry.ccm
@@ -1,28 +1,18 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <memory>
-#include <span>
-
+// This source code is released into the public domain.
 export module nihil.cli:registry;
 
+import nihil.std;
+
 namespace nihil {
 
 export struct command;
 export struct command_node;
 
-/*
- * Register a command.  This is guaranteed not to throw; errors will print
- * a diagnostic and exit.
- */
+// Register a command.  This is guaranteed not to throw; errors will print
+// a diagnostic and exit.
 auto register_command(command *cmd) noexcept -> void;
 
-/*
- * Get previously registered commands.
- */
+// Get previously registered commands.
 auto get_registered_commands() -> std::span<std::shared_ptr<command_node>>;
 
 } // namespace nihil
diff --git a/nihil.cli/test.cc b/nihil.cli/test.cc
index c82281e..61d164d 100644
--- a/nihil.cli/test.cc
+++ b/nihil.cli/test.cc
@@ -1,12 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <iostream>
-#include <vector>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.cli;
 import nihil.util;
 
@@ -34,9 +30,9 @@ TEST_CASE("nihil.cli: dispatch_command: basic", "[nihil.cli]")
 		auto args = std::vector<char const *>{
 			"cmd", "sub1", nullptr
 		};
-		auto argv = const_cast<char **>(args.data());
+		auto *argv = const_cast<char **>(args.data());
 
-		int ret = nihil::dispatch_command(
+		auto const ret = nihil::dispatch_command(
 				static_cast<int>(args.size()) - 1, argv);
 		REQUIRE(ret == 0);
 		REQUIRE(cmd_sub1_called == true);
@@ -47,9 +43,9 @@ TEST_CASE("nihil.cli: dispatch_command: basic", "[nihil.cli]")
 		auto args = std::vector<char const *>{
 			"cmd", "sub2", nullptr
 		};
-		auto argv = const_cast<char **>(args.data());
+		auto *argv = const_cast<char **>(args.data());
 
-		int ret = nihil::dispatch_command(
+		auto const ret = nihil::dispatch_command(
 				static_cast<int>(args.size()) - 1, argv);
 		REQUIRE(ret == 0);
 		REQUIRE(cmd_sub2_called == true);
@@ -61,7 +57,7 @@ TEST_CASE("nihil.cli: dispatch_command: unknown command", "[nihil.cli]")
 	auto args = std::vector<char const *>{
 		"nocomd", "sub", nullptr
 	};
-	auto argv = const_cast<char **>(args.data());
+	auto *argv = const_cast<char **>(args.data());
 
 	auto output = std::string();
 	auto ret = int{};
@@ -75,7 +71,7 @@ TEST_CASE("nihil.cli: dispatch_command: unknown command", "[nihil.cli]")
 
 	REQUIRE(ret == 1);
 
-	auto *progname = ::getprogname();
+	auto const *progname = ::getprogname();
 	REQUIRE(output == std::format("{}: usage:\n  cmd\n", progname));
 }
 
@@ -84,7 +80,7 @@ TEST_CASE("nihil.cli: dispatch_command: incomplete command", "[nihil.cli]")
 	auto args = std::vector<char const *>{
 		"cmd", nullptr
 	};
-	auto argv = const_cast<char **>(args.data());
+	auto *argv = const_cast<char **>(args.data());
 
 	auto output = std::string();
 	auto ret = int{};
@@ -98,7 +94,7 @@ TEST_CASE("nihil.cli: dispatch_command: incomplete command", "[nihil.cli]")
 
 	REQUIRE(ret == 1);
 
-	auto *progname = ::getprogname();
+	auto const *progname = ::getprogname();
 	REQUIRE(output == std::format("{}: usage:\n  cmd sub1\n  cmd sub2\n",
 				      progname));
 }
diff --git a/nihil.cli/usage_error.ccm b/nihil.cli/usage_error.ccm
index 61feba7..7de178e 100644
--- a/nihil.cli/usage_error.ccm
+++ b/nihil.cli/usage_error.ccm
@@ -1,22 +1,14 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <string>
-
+// This source code is released into the public domain.
 export module nihil.cli:usage_error;
 
+import nihil.std;
 import nihil.error;
 
 namespace nihil {
 
-/*
- * Exception thrown to indicate invalid command-line arguments.
- */
+// Exception thrown to indicate invalid command-line arguments.
 export struct usage_error : error {
-	usage_error(std::string_view what) : error(what) {}
+	explicit usage_error(std::string_view what) : error(what) {}
 };
 
 } // namespace nihil
diff --git a/nihil.config/CMakeLists.txt b/nihil.config/CMakeLists.txt
index 8a52d3c..6ed3651 100644
--- a/nihil.config/CMakeLists.txt
+++ b/nihil.config/CMakeLists.txt
@@ -2,6 +2,7 @@
 
 add_library(nihil.config STATIC)
 target_link_libraries(nihil.config PRIVATE
+	nihil.std
 	nihil.error
 	nihil.generator
 	nihil.posix
@@ -19,13 +20,21 @@ target_sources(nihil.config
 
 	PRIVATE
 	option.cc
-	read.cc
 	store.cc
-	string.cc
-	write.cc
 )
 
 if(NIHIL_TESTS)
-	add_subdirectory(tests)
+	add_executable(nihil.config.test
+		string.test.cc
+	)
+
+	target_link_libraries(nihil.config.test PRIVATE
+		nihil.config
+		Catch2::Catch2WithMain)
+
+	include(CTest)
+	include(Catch)
+	catch_discover_tests(nihil.config.test)
+
 	enable_testing()
 endif()
diff --git a/nihil.config/nihil.config.ccm b/nihil.config/nihil.config.ccm
index 8957305..8eedf22 100644
--- a/nihil.config/nihil.config.ccm
+++ b/nihil.config/nihil.config.ccm
@@ -1,9 +1,4 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
+// This source code is released into the public domain.
 export module nihil.config;
 
 export import :option;
diff --git a/nihil.config/option.cc b/nihil.config/option.cc
index 886f4b6..e09842e 100644
--- a/nihil.config/option.cc
+++ b/nihil.config/option.cc
@@ -1,16 +1,7 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <coroutine>
-#include <expected>
-#include <iostream>
-#include <string>
-
+// This source code is released into the public domain.
 module nihil.config;
 
+import nihil.std;
 import nihil.error;
 import nihil.monad;
 import nihil.ucl;
@@ -18,7 +9,7 @@ import nihil.ucl;
 namespace nihil::config {
 
 //NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-option::option(std::string_view name, std::string_view description)
+option::option(std::string_view const name, std::string_view const description)
 	: m_name(name)
 	, m_description(description)
 {
@@ -26,16 +17,15 @@ option::option(std::string_view name, std::string_view description)
 	if (okay)
 		return;
 
-	std::print(std::cerr,
+	std::println(std::cerr,
 		   "INTERNAL ERROR: failed to register "
 		   "configuration option '{}': {}",
 		   m_name, okay.error());
-	std::exit(1);
+	std::exit(1); // NOLINT
 }
 
 option::~option()
 {
-	std::ignore = store::get().unregister_option(this);
 }
 
 auto option::name(this option const &self) noexcept
diff --git a/nihil.config/option.ccm b/nihil.config/option.ccm
index 4b95793..0758c1a 100644
--- a/nihil.config/option.ccm
+++ b/nihil.config/option.ccm
@@ -1,32 +1,22 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <expected>
-#include <iosfwd>
-#include <string>
-
+// This source code is released into the public domain.
 export module nihil.config:option;
 
+import nihil.std;
 import nihil.error;
 import nihil.ucl;
 
 namespace nihil::config {
 
-/*
- * Base class for options; this is what config_store interacts with.
- *
- * Base classes should override the four protected functions:
- *
- * 	get_string()
- * 	set_string()
- * 	get_ucl()
- * 	set_ucl()
- *
- * Overriding any other members is not permitted.
- */
+// Base class for options; this is what config_store interacts with.
+//
+// Base classes should override the four protected functions:
+//
+// 	get_string()
+// 	set_string()
+// 	get_ucl()
+// 	set_ucl()
+//
+// Overriding any other members is not permitted.
 
 export struct option
 {
@@ -70,6 +60,9 @@ export struct option
 	option(option const &) = delete;
 	auto operator=(option const &) -> option& = delete;
 
+	option(option &&) = delete;
+	auto operator=(option &&) -> option& = delete;
+
 protected:
 	option(std::string_view name, std::string_view description);
 
diff --git a/nihil.config/read.cc b/nihil.config/read.cc
deleted file mode 100644
index 48484fb..0000000
--- a/nihil.config/read.cc
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <coroutine>
-#include <expected>
-#include <filesystem>
-#include <format>
-#include <iterator>
-#include <string>
-
-module nihil.config;
-
-import nihil.error;
-import nihil.monad;
-import nihil.posix;
-import nihil.ucl;
-
-namespace nihil::config {
-
-auto read_from(std::filesystem::path const &filename)
-	-> std::expected<void, error>
-{
-	// TODO: nihil.ucl should have a way to load UCL from a filename.
-
-	std::string config_text;
-	auto err = read_file(filename, std::back_inserter(config_text));
-	if (!err) {
-		// Ignore ENOENT, it simply means we haven't created the
-		// config file yet, so default values will be used.
-		if (err.error().root_cause() == std::errc::no_such_file_or_directory)
-			co_return {};
-		auto errstr = std::format("cannot read {}", filename.string());
-		co_return std::unexpected(error(errstr, err.error()));
-	}
-
-	// Parse the UCL.
-	auto uclconfig = co_await ucl::parse(config_text);
-
-	for (auto &&[key, value] : uclconfig) {
-		auto opt = co_await store::get().fetch(key);
-		co_await opt->ucl(value);
-	}
-
-	co_return {};
-}
-
-} // namespace nihil::config
diff --git a/nihil.config/read.ccm b/nihil.config/read.ccm
index 9cf28c9..7065492 100644
--- a/nihil.config/read.ccm
+++ b/nihil.config/read.ccm
@@ -1,22 +1,41 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <expected>
-#include <filesystem>
-
+// This source code is released into the public domain.
 export module nihil.config:read;
 
+import nihil.std;
 import nihil.error;
+import nihil.monad;
+import nihil.posix;
+import nihil.ucl;
+import :option;
+import :store;
 
 namespace nihil::config {
 
-/*
- * Load the configuration from a file.
- */
-export [[nodiscard]] auto read_from(std::filesystem::path const &filename)
-	-> std::expected<void, error>;
+// Load the configuration from a file.
+export [[nodiscard]] auto
+read_from(std::filesystem::path const &filename) -> std::expected<void, error>
+{
+	// TODO: nihil.ucl should have a way to load UCL from a filename.
+
+	auto config_text = std::string();
+	auto err = read_file(filename, std::back_inserter(config_text));
+	if (!err) {
+		// Ignore ENOENT, it simply means we haven't created the
+		// config file yet, so default values will be used.
+		if (err.error().root_cause() == std::errc::no_such_file_or_directory)
+			co_return {};
+		co_return std::unexpected(error(std::format("cannot read {}", filename.string()), err.error()));
+	}
+
+	// Parse the UCL.
+	auto uclconfig = co_await ucl::parse(config_text);
+
+	for (auto &&[key, value] : uclconfig) {
+		auto *opt = co_await store::get().fetch(key);
+		co_await opt->ucl(value);
+	}
+
+	co_return {};
+}
 
 } // namespace nihil::config
diff --git a/nihil.config/store.cc b/nihil.config/store.cc
index 0fb8cc0..e1ca271 100644
--- a/nihil.config/store.cc
+++ b/nihil.config/store.cc
@@ -1,17 +1,7 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <coroutine>
-#include <expected>
-#include <filesystem>
-#include <format>
-#include <map>
-
+// This source code is released into the public domain.
 module nihil.config;
 
+import nihil.std;
 import nihil.error;
 import nihil.generator;
 import nihil.monad;
diff --git a/nihil.config/store.ccm b/nihil.config/store.ccm
index 4d37ce0..0a92ef0 100644
--- a/nihil.config/store.ccm
+++ b/nihil.config/store.ccm
@@ -1,25 +1,16 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-/*
- * The configuration store.  There should only be one of these.
- */
-
-#include <coroutine>
-#include <expected>
-#include <string>
-#include <map>
-
+// This source code is released into the public domain.
 export module nihil.config:store;
 
+// The configuration store.  There should only be one of these.
+
+import nihil.std;
+import nihil.error;
 import nihil.generator;
-import :option;
 
 namespace nihil::config {
 
+export struct option;
+
 struct store final {
 	/*
 	 * Get the global config store.
@@ -57,8 +48,8 @@ struct store final {
 	// Not movable or copyable.
 	store(store const &) = delete;
 	store(store &&) = delete;
-	store& operator=(store const &) = delete;
-	store& operator=(store &&) = delete;
+	auto operator=(store const &) -> store & = delete;
+	auto operator=(store &&) -> store & = delete;
 
 private:
 	store();
diff --git a/nihil.config/string.cc b/nihil.config/string.cc
deleted file mode 100644
index 0ca4605..0000000
--- a/nihil.config/string.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <coroutine>
-#include <expected>
-#include <format>
-#include <string>
-
-module nihil.config;
-
-import nihil.error;
-import nihil.monad;
-import nihil.ucl;
-
-namespace nihil::config {
-
-string::string(
-	std::string &storage,
-	std::string_view name,
-	std::string_view description) noexcept
-	: option(name, description)
-	, m_storage(storage)
-{
-}
-
-string::~string() = default;
-
-auto string::get_string() const -> std::string
-{
-	return m_storage;
-}
-
-auto string::set_string(std::string_view new_value)
-	-> std::expected<void, error>
-{
-	m_storage = new_value;
-	return {};
-}
-
-auto string::get_ucl() const -> std::expected<ucl::object, error>
-{
-	return ucl::string(m_storage);
-}
-
-auto string::set_ucl(ucl::object const &uclobj) -> std::expected<void, error>
-{
-	auto obj = co_await object_cast<ucl::string>(uclobj)
-		.transform_error([&] (ucl::type_mismatch const &m) {
-			return error(std::format(
-				"'{}': expected string, not {}",
-				name(), str(m.actual_type())));
-		});
-
-	m_storage = obj.value();
-	is_default(false);
-	co_return {};
-}
-
-} // namespace nihil::config
diff --git a/nihil.config/string.ccm b/nihil.config/string.ccm
index 668bbc0..12ede7a 100644
--- a/nihil.config/string.ccm
+++ b/nihil.config/string.ccm
@@ -1,55 +1,68 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <expected>
-#include <format>
-#include <string>
-
+// This source code is released into the public domain.
 export module nihil.config:string;
 
+import nihil.std;
+import nihil.monad;
 import nihil.ucl;
 import :option;
 
 namespace nihil::config {
 
-/*
- * A string option.  The backing type is std::string.
- */
+// A string option.  The backing type is std::string.
 export struct string final : option
 {
-	string(std::string &storage,
-	       std::string_view name,
-	       std::string_view description) noexcept;
-
-	~string();
-
-	/*
-	 * Get this option as a string; simply returns the storage.
-	 */
-	[[nodiscard]] auto get_string() const -> std::string override;
-
-	/*
-	 * Set this option to a string value; assigns to the storage.
-	 */
-	[[nodiscard]] auto set_string(std::string_view new_value)
-		-> std::expected<void, error> override;
-
-	/*
-	 * Convert this option to a UCL object.
-	 */
-	[[nodiscard]] auto get_ucl() const
-		-> std::expected<ucl::object, error> override;
-
-	/*
-	 * Set this option from a UCL object.
-	 */
-	[[nodiscard]] auto set_ucl(ucl::object const &uclobj)
-		-> std::expected<void, error> override;
+	string(std::string &storage, std::string_view const name,
+	       std::string_view const description) noexcept
+		: option(name, description)
+		, m_storage(storage)
+	{
+	}
+
+	~string() override = default;
+
+	// Not copyable.
+	string(string const &) = delete;
+	auto operator=(string const &) -> string & = delete;
+
+	// Not movable.
+	string(string &&) = delete;
+	auto operator=(string &&) -> string & = delete;
 
 private:
+	// Get this option as a string; simply returns the storage.
+	[[nodiscard]] auto get_string() const -> std::string override
+	{
+		return m_storage;
+	}
+
+	// Set this option to a string value; assigns to the storage.
+	[[nodiscard]] auto
+	set_string(std::string_view const new_value) -> std::expected<void, error> override
+	{
+		m_storage = new_value;
+		return {};
+	}
+
+	// Convert this option to a UCL object.
+	[[nodiscard]] auto get_ucl() const -> std::expected<ucl::object, error> override
+	{
+		return ucl::make_string(m_storage);
+	}
+
+	// Set this option from a UCL object.
+	[[nodiscard]] auto set_ucl(ucl::object const &uclobj) -> std::expected<void, error> override
+	{
+		auto obj = co_await object_cast<ucl::string>(uclobj).transform_error(
+			[&](ucl::type_mismatch const &m) {
+				return error(std::format("'{}': expected string, not {}", name(),
+			                                 str(m.actual_type())));
+			});
+
+		m_storage = obj.value();
+		is_default(false);
+		co_return {};
+	}
+
 	std::string &m_storage;
 };
 
diff --git a/nihil.config/string.test.cc b/nihil.config/string.test.cc
new file mode 100644
index 0000000..322eb79
--- /dev/null
+++ b/nihil.config/string.test.cc
@@ -0,0 +1,32 @@
+// This source code is released into the public domain.
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil.std;
+import nihil.config;
+
+namespace {
+TEST_CASE("nihil.config: string option", "[nihil][nihil.config]")
+{
+	auto storage = std::string();
+
+	REQUIRE(nihil::config::get_option("test_option").has_value() == false);
+
+	{
+		auto string_option = nihil::config::string(
+			storage, "test_option", "This is a test option");
+
+		auto *opt = nihil::config::get_option("test_option").value();
+
+		REQUIRE(opt->name() == "test_option");
+		REQUIRE(opt->description() == "This is a test option");
+		REQUIRE(opt->is_default() == true);
+		REQUIRE(opt->string() == "");
+
+		REQUIRE(opt->string("testing"));
+		REQUIRE(storage == "testing");
+	}
+
+	REQUIRE(nihil::config::get_option("test_option").has_value() == false);
+}
+} // anonymous namespace
diff --git a/nihil.config/tests/CMakeLists.txt b/nihil.config/tests/CMakeLists.txt
deleted file mode 100644
index ffa60c3..0000000
--- a/nihil.config/tests/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-# This source code is released into the public domain.
-
-add_executable(nihil.config.test
-	string.cc
-)
-
-target_link_libraries(nihil.config.test PRIVATE
-	nihil.config
-	Catch2::Catch2WithMain)
-
-include(CTest)
-include(Catch)
-catch_discover_tests(nihil.config.test)
diff --git a/nihil.config/tests/string.cc b/nihil.config/tests/string.cc
deleted file mode 100644
index aeb1ef8..0000000
--- a/nihil.config/tests/string.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <string>
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil.config;
-
-TEST_CASE("nihil.config: string option", "[nihil][nihil.config]")
-{
-	std::string storage;
-
-	auto opt = nihil::config::get_option("test_option");
-	REQUIRE(!opt);
-
-	{
-		auto string_option = nihil::config::string(
-			storage, "test_option", "This is a test option");
-
-		auto opt = nihil::config::get_option("test_option");
-		REQUIRE(opt);
-
-		REQUIRE((*opt)->name() == "test_option");
-		REQUIRE((*opt)->description() == "This is a test option");
-		REQUIRE((*opt)->is_default() == true);
-		REQUIRE((*opt)->string() == "");
-
-		REQUIRE((*opt)->string("testing"));
-		REQUIRE(storage == "testing");
-	}
-
-	opt = nihil::config::get_option("test_option");
-	REQUIRE(!opt);
-}
diff --git a/nihil.config/write.cc b/nihil.config/write.cc
deleted file mode 100644
index 80125a8..0000000
--- a/nihil.config/write.cc
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <coroutine>
-#include <expected>
-#include <filesystem>
-#include <format>
-#include <utility>
-
-module nihil.config;
-
-import nihil.error;
-import nihil.monad;
-import nihil.posix;
-import nihil.ucl;
-
-namespace nihil::config {
-
-auto write_to(std::filesystem::path const &filename)
-	-> std::expected<void, error>
-{
-	auto uclconfig = ucl::map<ucl::object>();
-
-	// Add all the options to the UCL object.
-	for (auto const &option : store::get().all()) {
-		if (option->is_default())
-			continue;
-
-		auto uobj = co_await option->ucl();
-		uclconfig.insert({option->name(), uobj});
-	}
-
-	auto ucl_text = std::format("{:c}", uclconfig);
-	co_await safe_write_file(filename, ucl_text);
-	co_return {};
-}
-
-};
diff --git a/nihil.config/write.ccm b/nihil.config/write.ccm
index 564bb20..a7eddd5 100644
--- a/nihil.config/write.ccm
+++ b/nihil.config/write.ccm
@@ -1,22 +1,34 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <expected>
-#include <filesystem>
-
+// This source code is released into the public domain.
 export module nihil.config:write;
 
+import nihil.std;
 import nihil.error;
+import nihil.monad;
+import nihil.posix;
+import nihil.ucl;
+import :option;
+import :store;
 
 namespace nihil::config {
 
-/*
- * Write all config values (except defaults) to disk.
- */
-export [[nodiscard]] auto write_to(std::filesystem::path const &filename) ->
-	std::expected<void, error>;
+// Write all config values (except defaults) to disk.
+export [[nodiscard]] auto
+write_to(std::filesystem::path const &filename) -> std::expected<void, error>
+{
+	auto uclconfig = ucl::map<ucl::object>();
+
+	// Add all the options to the UCL object.
+	for (auto const &option : store::get().all()) {
+		if (option->is_default())
+			continue;
+
+		auto uobj = co_await option->ucl();
+		uclconfig.insert({option->name(), uobj});
+	}
+
+	auto ucl_text = std::format("{:c}", uclconfig);
+	co_await safe_write_file(filename, ucl_text);
+	co_return {};
+}
 
-};
+}; // namespace nihil::config
diff --git a/nihil.core/CMakeLists.txt b/nihil.core/CMakeLists.txt
index 2a7b3e2..cbb1b6b 100644
--- a/nihil.core/CMakeLists.txt
+++ b/nihil.core/CMakeLists.txt
@@ -1,11 +1,13 @@
 # This source code is released into the public domain.
 
 add_library(nihil.core STATIC)
+target_link_libraries(nihil.core PRIVATE nihil.std)
 target_include_directories(nihil.core PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_sources(nihil.core
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	nihil.core.ccm
 	errc.ccm
+	features.ccm
 
 	PRIVATE
 	errc.cc
diff --git a/nihil.core/errc.cc b/nihil.core/errc.cc
index 35c9d8f..411ad66 100644
--- a/nihil.core/errc.cc
+++ b/nihil.core/errc.cc
@@ -1,14 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <string>
-#include <system_error>
-
+// This source code is released into the public domain.
 module nihil.core;
 
+import nihil.std;
+
 namespace nihil {
 
 struct nihil_error_category final : std::error_category {
@@ -43,6 +37,10 @@ auto nihil_error_category::message(int err) const -> std::string
 		return "Empty string is not permitted";
 	case errc::invalid_unit:
 		return "Invalid unit specifier";
+	case errc::failed_to_create_object:
+		return "Failed to create UCL object";
+	case errc::type_mismatch:
+		return "UCL type does not match expected type";
 	default:
 		return "Undefined error";
 	}
diff --git a/nihil.core/errc.ccm b/nihil.core/errc.ccm
index c597faf..f5aac0b 100644
--- a/nihil.core/errc.ccm
+++ b/nihil.core/errc.ccm
@@ -1,28 +1,29 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <string>
-#include <system_error>
-
+// This source code is released into the public domain.
 export module nihil.core:errc;
 
+import nihil.std;
+
 namespace nihil {
 
-export enum struct errc {
+export enum struct errc : std::uint8_t {
 	no_error = 0,
 
-	/*
-	 * nihil.command
-	 */
+	//
+	// nihil.command
+	//
 
 	incomplete_command,
 
-	/*
-	 * nihil.util
-	 */
+	//
+	// nihil.ucl
+	//
+
+	failed_to_create_object,
+	type_mismatch,
+
+	//
+	// nihil.util
+	//
 
 	// Empty string is not allowed.
 	empty_string,
@@ -36,9 +37,5 @@ export [[nodiscard]] auto make_error_condition(errc ec) -> std::error_condition;
 
 } // namespace nihil
 
-namespace std {
-
-export template<>
-struct is_error_condition_enum<nihil::errc> : true_type {};
-
-} // namespace std
+template<>
+struct std::is_error_condition_enum<nihil::errc> : std::true_type {};
diff --git a/nihil.core/features.ccm b/nihil.core/features.ccm
new file mode 100644
index 0000000..5c6631b
--- /dev/null
+++ b/nihil.core/features.ccm
@@ -0,0 +1,13 @@
+// This source code is released into the public domain.
+module;
+
+#include "nihil.hh"
+
+export module nihil.core:features;
+
+namespace nihil::features {
+
+export inline constexpr bool fexecve = NIHIL_HAVE_FEXECVE;
+export inline constexpr bool getenv_r = NIHIL_HAVE_GETENV_R;
+
+} // namespace nihil::features
diff --git a/nihil.core/nihil.core.ccm b/nihil.core/nihil.core.ccm
index a7a4100..0aa5402 100644
--- a/nihil.core/nihil.core.ccm
+++ b/nihil.core/nihil.core.ccm
@@ -1,9 +1,5 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
+// This source code is released into the public domain.
 export module nihil.core;
 
 export import :errc;
+export import :features;
diff --git a/nihil.core/nihil.hh b/nihil.core/nihil.hh
index cd7e789..da37895 100644
--- a/nihil.core/nihil.hh
+++ b/nihil.core/nihil.hh
@@ -1,10 +1,11 @@
-/*
-* This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #ifndef NIHIL_HH_INCLUDED
 #define NIHIL_HH_INCLUDED
 
+#define NIHIL_HAVE_FEXECVE 0
+#define NIHIL_HAVE_GETENV_R 0
+
 #if __has_include(<sys/param.h>)
 #	include <sys/param.h>
 #endif
@@ -12,14 +13,16 @@
 #if defined(__FreeBSD_version)
 
 /* fexecve() added in FreeBSD 8.0 */
-#if (__FreeBSD_version >= 800000)
-#	define NIHIL_HAVE_FEXECVE
-#endif
+#	if (__FreeBSD_version >= 800000)
+#		undef NIHIL_HAVE_FEXECVE
+#		define NIHIL_HAVE_FEXECVE 1
+#	endif
 
 /* getenv_r() added in FreeBSD 15.0 */
-#if (__FreeBSD_version >= 1500000)
-#	define NIHIL_HAVE_GETENV_R
-#endif
+#	if (__FreeBSD_version >= 1500000)
+#		undef NIHIL_HAVE_GETENV_R
+#		define NIHIL_HAVE_GETENV_R 1
+#	endif
 
 #endif // defined(__FreeBSD_version)
 
diff --git a/nihil.error/CMakeLists.txt b/nihil.error/CMakeLists.txt
index 37fb3ab..fd5da84 100644
--- a/nihil.error/CMakeLists.txt
+++ b/nihil.error/CMakeLists.txt
@@ -1,13 +1,11 @@
 # This source code is released into the public domain.
 
 add_library(nihil.error STATIC)
-target_link_libraries(nihil.error PRIVATE nihil.match)
+target_link_libraries(nihil.error PRIVATE nihil.std nihil.match)
 target_sources(nihil.error
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	error.ccm
-
-	PRIVATE
-	error.cc
+	sys_error.ccm
 )
 
 if(NIHIL_TESTS)
diff --git a/nihil.error/error.cc b/nihil.error/error.cc
deleted file mode 100644
index e4023f9..0000000
--- a/nihil.error/error.cc
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <iostream>
-#include <memory>
-#include <optional>
-#include <string>
-#include <system_error>
-#include <variant>
-
-module nihil.error;
-
-import nihil.match;
-
-namespace nihil {
-
-auto to_string(error const &self) -> std::string
-{
-	auto ret = self.str();
-
-	auto cause = self.cause();
-	while (cause) {
-		ret += ": " + cause->str();
-		cause = cause->cause();
-	}
-
-	return ret;
-}
-
-error::error()
-{
-}
-
-error::~error() = default;
-
-error::error(std::string_view what, error cause)
-	: m_error(std::string(what))
-	, m_cause(std::make_shared<error>(std::move(cause)))
-{
-}
-error::error(std::string_view what)
-	: m_error(std::string(what))
-{
-}
-
-error::error(std::error_condition what, error cause)
-	: m_error(what)
-	, m_cause(std::make_shared<error>(std::move(cause)))
-{
-}
-
-error::error(std::error_condition what)
-	: m_error(what)
-{
-}
-
-error::error(std::error_code what, error cause)
-	: m_error(what)
-	, m_cause(std::make_shared<error>(std::move(cause)))
-{
-}
-
-error::error(std::error_code what)
-	: m_error(what)
-{
-}
-
-error::error(error const &) = default;
-error::error(error &&) noexcept = default;
-auto error::operator=(this error &, error const &) -> error & = default;
-auto error::operator=(this error &, error &&) noexcept -> error & = default;
-
-auto error::cause(this error const &self) -> std::shared_ptr<error>
-{
-	if (self.m_cause)
-		return self.m_cause;
-	return {};
-}
-
-auto error::root_cause(this error const &self) -> error const &
-{
-	if (self.m_cause)
-		return self.m_cause->root_cause();
-
-	return self; //NOLINT(bugprone-return-const-ref-from-parameter)
-}
-
-auto error::str(this error const &self) -> std::string
-{
-	return self.m_error | match {
-		[] (std::monostate) -> std::string {
-			return "No error";
-		},
-		[] (std::error_code const &m) {
-			return m.message();
-		},
-		[] (std::error_condition const &m) {
-			return m.message();
-		},
-		[] (std::string const &m) {
-			return m;
-		}
-	};
-}
-
-auto error::code(this error const &self) -> std::optional<std::error_code>
-{
-	auto const *code = std::get_if<std::error_code>(&self.m_error);
-	if (code)
-		return {*code};
-	return {};
-}
-
-auto error::condition(this error const &self)
-	-> std::optional<std::error_condition>
-{
-	auto const *condition = std::get_if<std::error_condition>(&self.m_error);
-	if (condition)
-		return {*condition};
-	return {};
-}
-
-auto error::what() const noexcept -> char const *
-{
-	if (!m_what)
-		m_what = to_string(*this);
-
-	return m_what->c_str();
-}
-
-auto operator==(error const &lhs, error const &rhs) -> bool
-{
-	return lhs.m_error == rhs.m_error;
-}
-
-auto operator<=>(error const &lhs, error const &rhs) -> std::strong_ordering
-{
-	return lhs.m_error <=> rhs.m_error;
-}
-
-auto operator==(error const &lhs, std::error_code const &rhs) -> bool
-{
-	return lhs.code() == rhs;
-}
-
-// Compare an error to an std::error_condition.
-auto operator==(error const &lhs, std::error_condition const &rhs) -> bool
-{
-	return lhs.condition() == rhs;
-}
-
-auto operator<<(std::ostream &strm, error const &e) -> std::ostream &
-{
-	return strm << to_string(e);
-}
-
-} // namespace nihil
diff --git a/nihil.error/error.ccm b/nihil.error/error.ccm
index 12d47cc..7ed9d5c 100644
--- a/nihil.error/error.ccm
+++ b/nihil.error/error.ccm
@@ -1,132 +1,261 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-/*
- * error: a type representing an error.
- *
- * An error consists of an immediate cause, which may be a string or
- * std:error_code, and an optional proximate cause, which is another error
- * object.  Any number of error objects may be stacked.
- *
- * For example, a failure to open a file might be a stack of two errors:
- *
- * - string, "failed to open /etc/somefile",
- * - std::error_code, "No such file or directory".
- *
- * Calling .str() will format the entire stack starting at that error,
- * for example: "failed to open /etc/somefile: No such file or directory".
- *
- * Errors may be moved and (relatively) cheaply copied, since the cause
- * chain is refcounted.
- *
- * error derives from std::exception, so it may be thrown and caught and
- * provides a useful what().  When throwing errors, creating a derived
- * error will make it easier to distinguish errors when catching them.
- */
-
-#include <iosfwd>
-#include <format>
-#include <memory>
-#include <optional>
-#include <string>
-#include <system_error>
-#include <utility>
-#include <variant>
-
+// This source code is released into the public domain.
 export module nihil.error;
 
+// error: a type representing an error.
+//
+// An error consists of an immediate cause, which may be a string or
+// std:error_code, and an optional proximate cause, which is another error
+// object.  Any number of error objects may be stacked.
+//
+// For example, a failure to open a file might be a stack of two errors:
+//
+// - string, "failed to open /etc/somefile",
+// - std::error_code, "No such file or directory".
+//
+// Calling .str() will format the entire stack starting at that error,
+// for example: "failed to open /etc/somefile: No such file or directory".
+//
+// Errors may be moved and (relatively) cheaply copied, since the cause
+// chain is refcounted.
+//
+// error derives from std::exception, so it may be thrown and caught and
+// provides a useful what().  When throwing errors, creating a derived
+// error will make it easier to distinguish errors when catching them.
+
+import nihil.std;
+import nihil.match;
+
+export import :sys_error;
+
 namespace nihil {
 
 // Things which can be errors.
-using error_t = std::variant<
-			std::monostate,
-			std::string,
-			std::error_code,
-			std::error_condition
-		>;
-
-export struct error : std::exception {
+using error_t = std::variant<std::monostate, std::string, std::error_code, std::error_condition>;
+
+export struct error : std::exception
+{
 	// Create an empty error, representing success.
-	error();
+	error() = default;
 
 	// Destroy an error.
-	~error() override;
+	~error() override = default;
 
 	// Create an error from a freeform string.
-	error(std::string_view what, error cause);
-	explicit error(std::string_view what);
+	explicit error(std::string_view what)
+		: m_error(std::string(what))
+	{
+	}
 
-	template<typename Cause>
+	// Create an error from a freeform string and a cause.
+	error(std::string_view what, error cause)
+		: m_error(std::string(what))
+		, m_cause(std::make_shared<error>(std::move(cause)))
+	{
+	}
+
+	// Create an error from a freeform string and an error code enum cause.
+	template <typename Cause>
 	requires(std::is_error_code_enum<Cause>::value ||
-		 std::is_error_condition_enum<Cause>::value)
+	         std::is_error_condition_enum<Cause>::value)
 	error(std::string_view what, Cause &&cause)
 		: error(what, error(std::forward<Cause>(cause)))
-	{}
+	{
+	}
+
+	// Create an error from an std::error_condition.
+	explicit error(std::error_condition what)
+		: m_error(what)
+	{
+	}
+
+	// Create an error from an std::error_condition and a cause.
+	error(std::error_condition what, error cause)
+		: m_error(what)
+		, m_cause(std::make_shared<error>(std::move(cause)))
+	{
+	}
 
 	// Create an error from an std::error_code.
-	error(std::error_condition what, error cause);
-	explicit error(std::error_condition what);
+	explicit error(std::error_code what)
+		: m_error(what)
+	{
+	}
 
-	// Create an error from an std::error_condition.
-	error(std::error_code what, error cause);
-	explicit error(std::error_code what);
+	// Create an error from an std::error_code and a cause.
+	error(std::error_code what, error cause)
+		: m_error(what)
+		, m_cause(std::make_shared<error>(std::move(cause)))
+	{
+	}
 
 	// Create an error from an std::error_code enum.
+	explicit error(auto errc)
+	requires(std::is_error_code_enum<decltype(errc)>::value)
+	: error(make_error_code(errc))
+	{
+	}
+
+	// Create an error from an std::error_code enum and a cause/
 	error(auto errc, error cause)
 	requires(std::is_error_code_enum<decltype(errc)>::value)
 		: error(make_error_code(errc), std::move(cause))
-	{}
+	{
+	}
 
+	// Create an error from an std::error_condition enum.
 	explicit error(auto errc)
-	requires(std::is_error_code_enum<decltype(errc)>::value)
-		: error(make_error_code(errc))
-	{}
+	requires(std::is_error_condition_enum<decltype(errc)>::value)
+		: error(make_error_condition(errc))
+	{
+	}
 
-	// Create an error from an std::error_condition enum.
+	// Create an error from an std::error_condition enum and a cause.
 	error(auto errc, error cause)
 	requires(std::is_error_condition_enum<decltype(errc)>::value)
 		: error(make_error_condition(errc), std::move(cause))
-	{}
-
-	explicit error(auto errc)
-	requires(std::is_error_condition_enum<decltype(errc)>::value)
-		: error(make_error_condition(errc))
-	{}
+	{
+	}
 
-	error(error const &);
-	error(error &&) noexcept;
+	// Copyable.
+	error(error const &) = default;
+	auto operator=(error const &) -> error & = default;
 
-	auto operator=(this error &, error const &) -> error &;
-	auto operator=(this error &, error &&) noexcept -> error &;
+	// Movable.
+	error(error &&) noexcept = default;
+	auto operator=(error &&) noexcept -> error & = default;
 
 	// Return the cause of this error.
-	[[nodiscard]] auto cause(this error const &) -> std::shared_ptr<error>;
+	[[nodiscard]] auto cause(this error const &self) -> std::shared_ptr<error> const &
+	{
+		return self.m_cause;
+	}
 
 	// Return the root cause of this error, which may be this object.
 	// For errors caused by an OS error, this will typically be the
 	// error_code error.
-	[[nodiscard]] auto root_cause(this error const &) -> error const &;
+	[[nodiscard]] auto root_cause(this error const &self) -> error const &
+	{
+		auto const *cause = &self;
+		while (cause->m_cause)
+			cause = cause->m_cause.get();
+		return *cause;
+	}
+
+	// Format this error without its cause as a string.
+	[[nodiscard]] auto this_str(this error const &self) -> std::string
+	{
+		return self.m_error | match {
+			[] (std::monostate) -> std::string {
+				return "No error";
+			},
+			[] (std::error_code const &m) {
+				return m.message();
+			},
+			[] (std::error_condition const &m) {
+				return m.message();
+			},
+			[] (std::string const &m) {
+				return m;
+			}
+		};
+	}
+
+	// Format this error and its cause as a string.
+	[[nodiscard]] auto full_str(this error const &self) -> std::string
+	{
+		auto str = self.this_str();
+
+		auto cause = self.cause();
+		while (cause) {
+			str += ": " + cause->this_str();
+			cause = cause->cause();
+		}
 
-	// Format this error as a string.
-	[[nodiscard]] auto str(this error const &) -> std::string;
+		return str;
+	}
 
 	// Return this error's error_code, if any.
-	[[nodiscard]] auto code(this error const &)
-		-> std::optional<std::error_code>;
+	[[nodiscard]] auto code(this error const &self) -> std::optional<std::error_code>
+	{
+		auto const *code = std::get_if<std::error_code>(&self.m_error);
+		if (code)
+			return {*code};
+		return {};
+	}
 
 	// Return this error's error_condition, if any.
-	[[nodiscard]] auto condition(this error const &)
-		-> std::optional<std::error_condition>;
+	[[nodiscard]] auto condition(this error const &self) -> std::optional<std::error_condition>
+	{
+		auto const *condition = std::get_if<std::error_condition>(&self.m_error);
+		if (condition)
+			return {*condition};
+		return {};
+	}
+
+	// Format this error and its cause as a C string and return it.  This is for
+	// compatibility with std::exception.  The lifetime of the returned string
+	// is the same as the error object.
+	[[nodiscard]] auto what() const noexcept -> char const * final
+	{
+		if (!m_what)
+			m_what = this->full_str();
+		return m_what->c_str();
+	}
+
+	// Allow error to be implicitly converted to std::expectde and std::unexpected, to make using it
+	// with std::expected easier.
+
+	template<typename T>
+	operator std::expected<T, error> () && // NOLINT
+	{
+		return std::unexpected{std::move(*this)};
+	}
+
+	template<typename T>
+	operator std::expected<T, error> () const // NOLINT
+	{
+		return std::unexpected{*this};
+	}
+
+	operator std::unexpected<error> () && // NOLINT
+	{
+		return std::unexpected{std::move(*this)};
+	}
 
-	[[nodiscard]] auto what() const noexcept -> char const * final;
+	operator std::unexpected<error> () const // NOLINT
+	{
+		return std::unexpected{*this};
+	}
 
 private:
-	friend auto operator==(error const &, error const &) -> bool;
-	friend auto operator<=>(error const &, error const &)
-		-> std::strong_ordering;
+	// Equality comparison.
+	[[nodiscard]] friend auto operator==(error const &lhs, error const &rhs) -> bool
+	{
+		return lhs.m_error == rhs.m_error;
+	}
+
+	[[nodiscard]] friend auto operator<=>(error const &lhs, error const &rhs) -> std::strong_ordering
+	{
+		return lhs.m_error <=> rhs.m_error;
+	}
+
+	// Compare an error with an std::error_code.
+	[[nodiscard]] friend auto operator==(error const &lhs, std::error_code const &rhs) -> bool
+	{
+		return lhs.code() == rhs;
+	}
+
+	// Compare an error to an std::error_condition.
+	[[nodiscard]] friend auto operator==(error const &lhs, std::error_condition const &rhs) -> bool
+	{
+		return lhs.condition() == rhs;
+	}
+
+	// Print an error to a stream.
+	friend auto operator<<(std::ostream &strm, error const &e) -> std::ostream &
+	{
+		return strm << e.full_str();
+	}
 
 	// This error.
 	error_t m_error = make_error_code(std::errc());
@@ -137,63 +266,37 @@ private:
 	// For std::exception::what(), we need to keep the string valid
 	// until we're destroyed.
 	mutable std::optional<std::string> m_what;
-};
-
-/*
- * Format an error and its cause(s) as a string.
- */
-export [[nodiscard]] auto to_string(error const &) -> std::string;
-
-// Compare an error to another error.  This only compares the error itself,
-// not any nested causes.
-export [[nodiscard]] auto operator==(error const &, error const &)
-	-> bool;
-export [[nodiscard]] auto operator<=>(error const &, error const &)
-	-> std::strong_ordering;
-
-// Compare an error to an std::error_code.
-export [[nodiscard]] auto operator==(error const &, std::error_code const &)
-	-> bool;
-
-// Compare an error to an std::error_condition.
-export [[nodiscard]] auto operator==(error const &,
-				     std::error_condition const &)
-	-> bool;
-
-// Compare an error to an std::error_code enum.
-export [[nodiscard]] auto operator==(error const &lhs, auto rhs) -> bool
-requires(std::is_error_code_enum<decltype(rhs)>::value)
-{
-	return lhs.code() == rhs;
-}
 
-// Compare an error to an std::error_condition enum.
-export [[nodiscard]] auto operator==(error const &lhs, auto rhs) -> bool
-requires(std::is_error_condition_enum<decltype(rhs)>::value)
-{
-	return lhs.condition() == rhs;
-}
+	// Compare an error to an std::error_code enum.
+	[[nodiscard]] friend auto operator==(error const &lhs, auto rhs) -> bool
+	requires(std::is_error_code_enum<decltype(rhs)>::value)
+	{
+		return lhs.code() == rhs;
+	}
 
-// Print an error to an ostream.
-export [[nodiscard]] auto operator<<(std::ostream &, error const &)
-	-> std::ostream &;
+	// Compare an error to an std::error_condition enum.
+	[[nodiscard]] friend auto operator==(error const &lhs, auto rhs) -> bool
+	requires(std::is_error_condition_enum<decltype(rhs)>::value)
+	{
+		return lhs.condition() == rhs;
+	}
+};
 
 } // namespace nihil
 
 // Make error formattable.
-export template<>
+export template <>
 struct std::formatter<nihil::error, char>
 {
-	template<typename ParseContext>
+	template <typename ParseContext>
 	constexpr auto parse(ParseContext &ctx) -> ParseContext::iterator
 	{
 		return ctx.begin();
 	}
 
-	template<typename FormatContext>
-	auto format(nihil::error const &e, FormatContext &ctx) const
-		-> FormatContext::iterator
+	template <typename FormatContext>
+	auto format(nihil::error const &e, FormatContext &ctx) const -> FormatContext::iterator
 	{
-		return std::ranges::copy(to_string(e), ctx.out()).out;
+		return std::ranges::copy(e.full_str(), ctx.out()).out;
 	}
 };
diff --git a/nihil.error/sys_error.ccm b/nihil.error/sys_error.ccm
new file mode 100644
index 0000000..102f4c5
--- /dev/null
+++ b/nihil.error/sys_error.ccm
@@ -0,0 +1,18 @@
+// This source code is released into the public domain.
+module;
+
+#include <cerrno>
+
+export module nihil.error:sys_error;
+
+import nihil.std;
+
+namespace nihil {
+
+// Allow access to errno without having to include <cerrno>.
+export [[nodiscard]] auto sys_error() -> std::errc
+{
+	return static_cast<std::errc>(errno);
+}
+
+} // namespace nihil
diff --git a/nihil.error/test.cc b/nihil.error/test.cc
index 9b3eef1..0f4f93f 100644
--- a/nihil.error/test.cc
+++ b/nihil.error/test.cc
@@ -1,13 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <cerrno>
-#include <cstring>
-#include <system_error>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.error;
 
 TEST_CASE("error: invariants", "[nihil]")
@@ -27,9 +22,9 @@ TEST_CASE("error: construct from string", "[nihil]")
 	using namespace nihil;
 
 	auto e = error("an error");
-	REQUIRE(e.str() == to_string(e));
-	REQUIRE(to_string(e) == "an error");
-	REQUIRE(std::format("{}", e) == to_string(e));
+	REQUIRE(e.full_str() == "an error");
+	REQUIRE(e.this_str() == e.full_str());
+	REQUIRE(std::format("{}", e) == e.full_str());
 }
 
 TEST_CASE("error: construct from std::error_condition", "[nihil]")
@@ -46,9 +41,9 @@ TEST_CASE("error: construct from std::error_condition", "[nihil]")
 	REQUIRE(e == std::errc::invalid_argument);
 	REQUIRE(e != std::errc::no_such_file_or_directory);
 
-	REQUIRE(e.str() == to_string(e));
-	REQUIRE(to_string(e) == std::strerror(EINVAL));
-	REQUIRE(std::format("{}", e) == to_string(e));
+	REQUIRE(e.full_str() == std::strerror(EINVAL));
+	REQUIRE(e.this_str() == e.full_str());
+	REQUIRE(std::format("{}", e) == e.full_str());
 }
 
 TEST_CASE("error: construct from std::errc", "[nihil]")
@@ -64,9 +59,9 @@ TEST_CASE("error: construct from std::errc", "[nihil]")
 	REQUIRE(e == std::errc::invalid_argument);
 	REQUIRE(e != std::errc::no_such_file_or_directory);
 
-	REQUIRE(e.str() == to_string(e));
-	REQUIRE(to_string(e) == std::strerror(EINVAL));
-	REQUIRE(std::format("{}", e) == to_string(e));
+	REQUIRE(e.full_str() == std::strerror(EINVAL));
+	REQUIRE(e.this_str() == e.full_str());
+	REQUIRE(std::format("{}", e) == e.full_str());
 }
 
 TEST_CASE("error: compound error", "[nihil]")
@@ -82,10 +77,10 @@ TEST_CASE("error: compound error", "[nihil]")
 	REQUIRE(e.condition().has_value() == false);
 
 	REQUIRE(*e.cause() == std::errc::no_such_file_or_directory);
-	REQUIRE(e.str() == "cannot open file");
-	REQUIRE(to_string(e) == ("cannot open file: "s +
-				 std::strerror(ENOENT)));
-	REQUIRE(std::format("{}", e) == to_string(e));
+
+	REQUIRE(e.full_str() == ("cannot open file: "s + std::strerror(ENOENT)));
+	REQUIRE(e.this_str() == "cannot open file");
+	REQUIRE(std::format("{}", e) == e.full_str());
 }
 
 TEST_CASE("error: operator== with strings", "[nihil]")
diff --git a/nihil.flagset/CMakeLists.txt b/nihil.flagset/CMakeLists.txt
index bdc31ce..40d106e 100644
--- a/nihil.flagset/CMakeLists.txt
+++ b/nihil.flagset/CMakeLists.txt
@@ -1,6 +1,7 @@
 # This source code is released into the public domain.
 
 add_library(nihil.flagset STATIC)
+target_link_libraries(nihil.flagset PRIVATE nihil.std)
 target_sources(nihil.flagset
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	flagset.ccm
diff --git a/nihil.flagset/flagset.ccm b/nihil.flagset/flagset.ccm
index 8369b75..5bd7720 100644
--- a/nihil.flagset/flagset.ccm
+++ b/nihil.flagset/flagset.ccm
@@ -1,20 +1,11 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
+// This source code is released into the public domain.
+export module nihil.flagset;
 
 /*
- * flagset: a type-type flags type.
+ * flagset: a type-safe flags type.
  */
 
-#include <concepts>
-#include <cstdint>
-#include <iostream>
-#include <limits>
-#include <print>
-
-export module nihil.flagset;
+import nihil.std;
 
 namespace nihil {
 
diff --git a/nihil.flagset/test.cc b/nihil.flagset/test.cc
index c3ebd35..90eef4a 100644
--- a/nihil.flagset/test.cc
+++ b/nihil.flagset/test.cc
@@ -1,18 +1,14 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <concepts>
-#include <format>
-#include <sstream>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.flagset;
 
 namespace {
-
-struct test_tag{};
+struct test_tag
+{
+};
 using testflags = nihil::flagset<unsigned, test_tag>;
 
 constexpr auto zero = testflags::bit<0>();
@@ -20,8 +16,6 @@ constexpr auto one = testflags::bit<1>();
 constexpr auto two = testflags::bit<2>();
 constexpr auto twelve = testflags::bit<12>();
 
-}
-
 TEST_CASE("flagset: invariant", "[nihil]")
 {
 	static_assert(std::regular<testflags>);
@@ -45,17 +39,17 @@ TEST_CASE("flagset: mask<>", "[nihil]")
 
 TEST_CASE("flagset: constructor", "[nihil]")
 {
-	SECTION("default construct") {
+	SECTION ("default construct") {
 		auto flags = testflags();
 		REQUIRE(flags.value() == 0);
 	}
 
-	SECTION("construct from int") {
+	SECTION ("construct from int") {
 		auto flags = testflags::from_int(one.value() | zero.value());
 		REQUIRE(flags == (one | zero));
 	}
 
-	SECTION("copy construct") {
+	SECTION ("copy construct") {
 		auto flags = one;
 		auto flags2(flags);
 		REQUIRE(flags == flags2);
@@ -64,46 +58,46 @@ TEST_CASE("flagset: constructor", "[nihil]")
 
 TEST_CASE("flagset: operators", "[nihil]")
 {
-	SECTION("operator|") {
+	SECTION ("operator|") {
 		REQUIRE((zero | one).value() == 0x3);
 	}
 
-	SECTION("operator|=") {
+	SECTION ("operator|=") {
 		auto flags = zero;
 		flags |= one;
 		REQUIRE(flags.value() == 0x3);
 	}
 
-	SECTION("operator&") {
+	SECTION ("operator&") {
 		auto flags = zero | one;
 
 		REQUIRE((flags & zero) == zero);
 	}
 
-	SECTION("operator&=") {
+	SECTION ("operator&=") {
 		auto flags = zero | one | two;
 		REQUIRE(flags.value() == 0x7);
 		flags &= (zero | one);
 		REQUIRE(flags.value() == 0x3);
 	}
 
-	SECTION("operator^") {
+	SECTION ("operator^") {
 		auto flags = zero | one;
 		REQUIRE((flags ^ (one | two)) == (zero | two));
 	}
 
-	SECTION("operator^=") {
+	SECTION ("operator^=") {
 		auto flags = zero | one;
 		flags ^= (one | two);
 		REQUIRE(flags == (zero | two));
 	}
 
-	SECTION("operator~") {
+	SECTION ("operator~") {
 		auto flags = ~zero;
 		REQUIRE(flags.value() == ~static_cast<unsigned>(1));
 	}
 
-	SECTION("operator==") {
+	SECTION ("operator==") {
 		auto flags = zero;
 		REQUIRE(flags == zero);
 		REQUIRE(flags != one);
@@ -133,7 +127,7 @@ TEST_CASE("flagset: format", "[nihil]")
 
 TEST_CASE("flagset: ostream operator<<", "[nihil]")
 {
-	auto write = [] (testflags flags) -> std::string {
+	auto write = [](testflags flags) -> std::string {
 		auto strm = std::ostringstream();
 		strm << flags;
 		return strm.str();
@@ -147,3 +141,4 @@ TEST_CASE("flagset: ostream operator<<", "[nihil]")
 	REQUIRE(write(twelve) == "<12>");
 	REQUIRE(write(twelve | one) == "<12,1>");
 }
+} // anonymous namespace
diff --git a/nihil.generator/CMakeLists.txt b/nihil.generator/CMakeLists.txt
index e521159..d9eb854 100644
--- a/nihil.generator/CMakeLists.txt
+++ b/nihil.generator/CMakeLists.txt
@@ -1,6 +1,7 @@
 # This source code is released into the public domain.
 
 add_library(nihil.generator STATIC)
+target_link_libraries(nihil.generator PRIVATE nihil.std)
 target_sources(nihil.generator
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	nihil.generator.ccm
diff --git a/nihil.generator/byte_allocator.ccm b/nihil.generator/byte_allocator.ccm
index 6d46ec6..86b2edf 100644
--- a/nihil.generator/byte_allocator.ccm
+++ b/nihil.generator/byte_allocator.ccm
@@ -11,13 +11,10 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <memory>
-#include <type_traits>
-
 export module nihil.generator:byte_allocator;
 
+import nihil.std;
+
 namespace nihil {
 
 template <typename Alloc>
diff --git a/nihil.generator/coroutine_traits.ccm b/nihil.generator/coroutine_traits.ccm
index 2a9d51d..fde4393 100644
--- a/nihil.generator/coroutine_traits.ccm
+++ b/nihil.generator/coroutine_traits.ccm
@@ -11,13 +11,9 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <coroutine>
-#include <memory>
-
 export module nihil.generator:coroutine_traits;
 
+import nihil.std;
 import :byte_allocator;
 import :forward;
 import :generator_promise;
diff --git a/nihil.generator/elements_of.ccm b/nihil.generator/elements_of.ccm
index 0e34eb9..74c8b76 100644
--- a/nihil.generator/elements_of.ccm
+++ b/nihil.generator/elements_of.ccm
@@ -11,12 +11,9 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <concepts>
-
 export module nihil.generator:elements_of;
 
+import nihil.std;
 import :util;
 
 namespace nihil {
diff --git a/nihil.generator/forward.ccm b/nihil.generator/forward.ccm
index 8d5ca4d..71e0ddd 100644
--- a/nihil.generator/forward.ccm
+++ b/nihil.generator/forward.ccm
@@ -11,12 +11,9 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <type_traits>
-
 export module nihil.generator:forward;
 
+import nihil.std;
 import :util;
 
 namespace nihil {
diff --git a/nihil.generator/generator.ccm b/nihil.generator/generator.ccm
index 96790a8..7627052 100644
--- a/nihil.generator/generator.ccm
+++ b/nihil.generator/generator.ccm
@@ -14,15 +14,10 @@
 module;
 
 #include <cassert>
-#include <coroutine>
-#include <exception>
-#include <memory>
-#include <ranges>
-#include <type_traits>
-#include <utility>
 
 export module nihil.generator:generator;
 
+import nihil.std;
 import :byte_allocator;
 import :coroutine_traits;
 import :elements_of;
diff --git a/nihil.generator/generator.test.cc b/nihil.generator/generator.test.cc
index 49272b4..59a2c45 100644
--- a/nihil.generator/generator.test.cc
+++ b/nihil.generator/generator.test.cc
@@ -1,13 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <coroutine>
-#include <ranges>
-#include <vector>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.generator;
 
 TEST_CASE("generator: basic", "[generator]") 
diff --git a/nihil.generator/generator_promise.ccm b/nihil.generator/generator_promise.ccm
index b0fd4b1..3e8aa8c 100644
--- a/nihil.generator/generator_promise.ccm
+++ b/nihil.generator/generator_promise.ccm
@@ -11,13 +11,9 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <coroutine>
-#include <ranges>
-
 export module nihil.generator:generator_promise;
 
+import nihil.std;
 import :forward;
 import :generator_promise_base;
 import :promise_base_alloc;
diff --git a/nihil.generator/generator_promise_base.ccm b/nihil.generator/generator_promise_base.ccm
index fec9b1b..30c3011 100644
--- a/nihil.generator/generator_promise_base.ccm
+++ b/nihil.generator/generator_promise_base.ccm
@@ -11,14 +11,9 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <coroutine>
-#include <exception>
-#include <memory>
-
 export module nihil.generator:generator_promise_base;
 
+import nihil.std;
 import :elements_of;
 import :forward;
 import :manual_lifetime;
diff --git a/nihil.generator/manual_lifetime.ccm b/nihil.generator/manual_lifetime.ccm
index 963e6c9..4a383ad 100644
--- a/nihil.generator/manual_lifetime.ccm
+++ b/nihil.generator/manual_lifetime.ccm
@@ -11,13 +11,10 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <concepts>
-#include <memory>
-
 export module nihil.generator:manual_lifetime;
 
+import nihil.std;
+
 namespace nihil {
 
 template <typename T>
diff --git a/nihil.generator/nihil.generator.ccm b/nihil.generator/nihil.generator.ccm
index 550a4c7..fc6a097 100644
--- a/nihil.generator/nihil.generator.ccm
+++ b/nihil.generator/nihil.generator.ccm
@@ -11,12 +11,10 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <ranges>
-
 export module nihil.generator;
 
+import nihil.std;
+
 export import :coroutine_traits;
 export import :elements_of;
 export import :generator;
diff --git a/nihil.generator/promise_base_alloc.ccm b/nihil.generator/promise_base_alloc.ccm
index e59fc57..7fd544b 100644
--- a/nihil.generator/promise_base_alloc.ccm
+++ b/nihil.generator/promise_base_alloc.ccm
@@ -11,13 +11,9 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <cstdlib>
-#include <memory>
-
 export module nihil.generator:promise_base_alloc;
 
+import nihil.std;
 import :util;
 
 namespace nihil {
diff --git a/nihil.generator/util.ccm b/nihil.generator/util.ccm
index 4d732b9..259499a 100644
--- a/nihil.generator/util.ccm
+++ b/nihil.generator/util.ccm
@@ -11,13 +11,10 @@
 // (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
 ///////////////////////////////////////////////////////////////////////////////
 
-module;
-
-#include <concepts>
-#include <memory>
-
 export module nihil.generator:util;
 
+import nihil.std;
+
 namespace nihil {
 
 export struct use_allocator_arg {};
diff --git a/nihil.guard/CMakeLists.txt b/nihil.guard/CMakeLists.txt
index 436728a..a5e0fc2 100644
--- a/nihil.guard/CMakeLists.txt
+++ b/nihil.guard/CMakeLists.txt
@@ -1,6 +1,7 @@
 # This source code is released into the public domain.
 
 add_library(nihil.guard STATIC)
+target_link_libraries(nihil.guard PRIVATE nihil.std)
 target_sources(nihil.guard
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	guard.ccm
diff --git a/nihil.guard/guard.ccm b/nihil.guard/guard.ccm
index 84ff401..fdda45c 100644
--- a/nihil.guard/guard.ccm
+++ b/nihil.guard/guard.ccm
@@ -1,13 +1,8 @@
 // This source code is released into the public domain.
-module;
-
-#include <concepts>
-#include <functional>
-#include <optional>
-#include <utility>
-
 export module nihil.guard;
 
+import nihil.std;
+
 namespace nihil {
 
 // guard: invoke a callable when this object is destroyed; this is similar to
diff --git a/nihil.guard/test.cc b/nihil.guard/test.cc
index 11f7d37..f1b3f21 100644
--- a/nihil.guard/test.cc
+++ b/nihil.guard/test.cc
@@ -1,13 +1,9 @@
-/*
- * This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
 import nihil.guard;
 
-using namespace std::literals;
-
 TEST_CASE("guard: basic", "[guard]") {
 	int n = 0;
 
diff --git a/nihil.match/CMakeLists.txt b/nihil.match/CMakeLists.txt
index 283c54f..da59663 100644
--- a/nihil.match/CMakeLists.txt
+++ b/nihil.match/CMakeLists.txt
@@ -1,6 +1,7 @@
 # This source code is released into the public domain.
 
 add_library(nihil.match STATIC)
+target_link_libraries(nihil.match PRIVATE nihil.std)
 target_sources(nihil.match
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	match.ccm
diff --git a/nihil.match/match.ccm b/nihil.match/match.ccm
index d67bd0b..03730bb 100644
--- a/nihil.match/match.ccm
+++ b/nihil.match/match.ccm
@@ -1,13 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <variant>
-
+// This source code is released into the public domain.
 export module nihil.match;
 
+import nihil.std;
+
 namespace nihil {
 
 export template<class... Ts>
diff --git a/nihil.match/test.cc b/nihil.match/test.cc
index 7dd1c34..974a58a 100644
--- a/nihil.match/test.cc
+++ b/nihil.match/test.cc
@@ -1,12 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <string>
-#include <variant>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.match;
 
 TEST_CASE("match", "[nihil]")
diff --git a/nihil.monad/CMakeLists.txt b/nihil.monad/CMakeLists.txt
index c293d40..f82e464 100644
--- a/nihil.monad/CMakeLists.txt
+++ b/nihil.monad/CMakeLists.txt
@@ -1,7 +1,7 @@
 # This source code is released into the public domain.
 
 add_library(nihil.monad STATIC)
-target_link_libraries(nihil.monad PRIVATE nihil.error)
+target_link_libraries(nihil.monad PRIVATE nihil.std nihil.error)
 target_sources(nihil.monad
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	monad.ccm
diff --git a/nihil.monad/monad.ccm b/nihil.monad/monad.ccm
index 898f1ee..cd17e0f 100644
--- a/nihil.monad/monad.ccm
+++ b/nihil.monad/monad.ccm
@@ -22,16 +22,10 @@
  * IN THE SOFTWARE.
  */
 
-module;
-
-#include <coroutine>
-#include <exception>
-#include <expected>
-#include <optional>
-#include <utility>
-
 export module nihil.monad;
 
+import nihil.std;
+
 namespace nihil {
 
 /**********************************************************************
@@ -228,8 +222,7 @@ struct expected_promise<void, E> : expected_promise_base<void, E> {
 		self.data->emplace(std::move(err));
 	}
 
-	void return_value(this expected_promise &self,
-			  std::expected<void, E> o)
+	void return_value(this expected_promise &self, std::expected<void, E> o)
 	{
 		self.data->emplace(std::move(o));
 	}
diff --git a/nihil.monad/test.cc b/nihil.monad/test.cc
index 347acdb..2cc743c 100644
--- a/nihil.monad/test.cc
+++ b/nihil.monad/test.cc
@@ -1,13 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <coroutine>
-#include <expected>
-#include <optional>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.error;
 import nihil.monad;
 
diff --git a/nihil.posix/CMakeLists.txt b/nihil.posix/CMakeLists.txt
index 1fcc365..d76ae4d 100644
--- a/nihil.posix/CMakeLists.txt
+++ b/nihil.posix/CMakeLists.txt
@@ -2,7 +2,14 @@
 
 add_library(nihil.posix STATIC)
 target_link_libraries(nihil.posix PRIVATE
-	nihil.core nihil.error nihil.flagset nihil.guard nihil.monad)
+	nihil.std
+	nihil.core
+	nihil.error
+	nihil.flagset
+	nihil.guard
+	nihil.monad
+	nihil.util
+)
 
 target_sources(nihil.posix
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
@@ -17,18 +24,19 @@ target_sources(nihil.posix
 	execvp.ccm
 	executor.ccm
 	fd.ccm
-	fexecv.ccm
-	fexecvp.ccm
 	find_in_path.ccm
 	getenv.ccm
 	open.ccm
 	open_in_path.ccm
+	paths.ccm
 	process.ccm
 	read_file.ccm
 	rename.ccm
 	spawn.ccm
 	stat.ccm
 	tempfile.ccm
+	unistd.ccm
+	unlink.ccm
 	write_file.ccm
 )
 
diff --git a/nihil.posix/argv.ccm b/nihil.posix/argv.ccm
index de75770..230ae9a 100644
--- a/nihil.posix/argv.ccm
+++ b/nihil.posix/argv.ccm
@@ -1,16 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <memory>
-#include <ranges>
-#include <string>
-#include <vector>
-
+// This source code is released into the public domain.
 export module nihil.posix:argv;
 
+import nihil.std;
+
 namespace nihil {
 
 /*
diff --git a/nihil.posix/argv.test.cc b/nihil.posix/argv.test.cc
index 3cc218d..e71c3da 100644
--- a/nihil.posix/argv.test.cc
+++ b/nihil.posix/argv.test.cc
@@ -1,14 +1,8 @@
-/*
- * This source code is released into the public domain
- */
-
-#include <algorithm>
-#include <string>
-#include <type_traits>
-#include <vector>
+// This source code is released into the public domain
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.posix;
 
 namespace {
diff --git a/nihil.posix/ensure_dir.ccm b/nihil.posix/ensure_dir.ccm
index 7eecea8..8d3e7a8 100644
--- a/nihil.posix/ensure_dir.ccm
+++ b/nihil.posix/ensure_dir.ccm
@@ -1,15 +1,7 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <expected>
-#include <filesystem>
-#include <system_error>
-
+// This source code is released into the public domain.
 export module nihil.posix:ensure_dir;
 
+import nihil.std;
 import nihil.error;
 
 namespace nihil {
diff --git a/nihil.posix/execl.ccm b/nihil.posix/execl.ccm
index f3cbf9a..99b9169 100644
--- a/nihil.posix/execl.ccm
+++ b/nihil.posix/execl.ccm
@@ -1,40 +1,25 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <expected>
-#include <string>
-
-#include "nihil.hh"
-
+// This source code is released into the public domain.
 export module nihil.posix:execl;
 
+import nihil.std;
 import nihil.error;
 import :argv;
 import :execv;
-import :fexecv;
+import :fd;
 
 namespace nihil {
 
-/*
- * execl: equivalent to (f)execv, except the arguments are passed as a
- * variadic pack of string-like objects.
- */
+// execl: equivalent to execv, except the arguments are passed as a
+// variadic pack of string-like objects.
 
-export [[nodiscard]] auto execl(std::string_view path, auto &&...args) -> execv
+export [[nodiscard]] auto execl(std::filesystem::path path, auto &&...args) -> execv
 {
-	return execv(path, argv({std::string_view(args)...}));
+	return execv(std::move(path), argv({std::string_view(args)...}));
 }
 
-#ifdef NIHIL_HAVE_FEXECVE
-
-export [[nodiscard]] auto execl(fd &&executable, auto &&...args) -> fexecv
+export [[nodiscard]] auto execl(fd &&executable, auto &&...args) -> execv
 {
-	return fexecv(std::move(executable), argv({std::string_view(args)...}));
+	return execv(std::move(executable), argv({std::string_view(args)...}));
 }
 
-#endif // NIHIL_HAVE_FEXECVE
-
 } // namespace nihil
diff --git a/nihil.posix/execl.test.cc b/nihil.posix/execl.test.cc
index 5aaaa25..51c2bb9 100644
--- a/nihil.posix/execl.test.cc
+++ b/nihil.posix/execl.test.cc
@@ -1,9 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.posix;
 
 namespace {
diff --git a/nihil.posix/execlp.ccm b/nihil.posix/execlp.ccm
index ab3737c..12f2c24 100644
--- a/nihil.posix/execlp.ccm
+++ b/nihil.posix/execlp.ccm
@@ -1,12 +1,7 @@
 // This source code is released into the public domain.
-module;
-
-#include <expected>
-#include <format>
-#include <string>
-
 export module nihil.posix:execlp;
 
+import nihil.std;
 import nihil.error;
 import :argv;
 import :execvp;
@@ -15,8 +10,9 @@ namespace nihil {
 
 // execlp: equivalent to execvp, except the arguments are passed as a
 // variadic pack of string-like objects.
+
 export [[nodiscard]] auto
-execlp(std::string_view file, auto &&...args) -> std::expected<execv, error>
+execlp(std::filesystem::path const &file, auto &&...args) -> std::expected<execv, error>
 {
 	return execvp(file, argv({std::string_view(args)...}));
 }
diff --git a/nihil.posix/execlp.test.cc b/nihil.posix/execlp.test.cc
index aa32253..6fdccea 100644
--- a/nihil.posix/execlp.test.cc
+++ b/nihil.posix/execlp.test.cc
@@ -1,9 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.posix;
 
 namespace {
diff --git a/nihil.posix/execshell.ccm b/nihil.posix/execshell.ccm
index 1fbfccf..e0263e5 100644
--- a/nihil.posix/execshell.ccm
+++ b/nihil.posix/execshell.ccm
@@ -1,10 +1,7 @@
 // This source code is released into the public domain.
-module;
-
-#include <string>
-
 export module nihil.posix:execshell;
 
+import nihil.std;
 import nihil.error;
 import :execv;
 import :execl;
diff --git a/nihil.posix/execshell.test.cc b/nihil.posix/execshell.test.cc
index b64953a..47e3313 100644
--- a/nihil.posix/execshell.test.cc
+++ b/nihil.posix/execshell.test.cc
@@ -1,9 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.posix;
 
 namespace {
diff --git a/nihil.posix/executor.ccm b/nihil.posix/executor.ccm
index f348dc8..d9bde88 100644
--- a/nihil.posix/executor.ccm
+++ b/nihil.posix/executor.ccm
@@ -1,19 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <concepts>
-#include <type_traits>
-
+// This source code is released into the public domain.
 export module nihil.posix:executor;
 
+import nihil.std;
+
 namespace nihil {
 
-/*
- * A concept to mark spawn executors.
- */
+// A concept to mark spawn executors, which should contain:
+//	using tag = exec_tag;
 
 export struct exec_tag{};
 
diff --git a/nihil.posix/execv.ccm b/nihil.posix/execv.ccm
index ef9d259..d598d94 100644
--- a/nihil.posix/execv.ccm
+++ b/nihil.posix/execv.ccm
@@ -1,17 +1,17 @@
 // This source code is released into the public domain.
 module;
 
-#include <expected>
-#include <filesystem>
-#include <string>
-
-#include <unistd.h>
+#include <unistd.h> // execv()
 
 export module nihil.posix:execv;
 
+import nihil.std;
 import nihil.error;
+import nihil.match;
+import nihil.util;
 import :argv;
 import :executor;
+import :fd;
 
 namespace nihil {
 
@@ -20,12 +20,19 @@ export struct execv final
 {
 	using tag = exec_tag;
 
+	// Construct an execv from a filename.
 	execv(std::filesystem::path path, argv &&args) noexcept
-		: m_path(std::move(path))
+		: m_executable(std::move(path))
 		, m_args(std::move(args))
 	{
 	}
 
+	// Construct an execv from a file descriptor
+	execv(fd &&executable, argv &&argv) noexcept
+		: m_executable(std::move(executable))
+		, m_args(std::move(argv))
+	{}
+
 	~execv() = default;
 
 	// Movable
@@ -39,12 +46,30 @@ export struct execv final
 	// Perform the execv().  This only returns on failure.
 	[[nodiscard]] auto exec(this execv &self) -> std::expected<void, error>
 	{
-		::execv(self.m_path.string().c_str(), self.m_args.data());
-		return std::unexpected(error("execve failed", error(std::errc(errno))));
+		auto guard = save_errno();
+
+		return self.m_executable | match {
+			[&] (std::filesystem::path const &path) {
+				::execv(path.string().c_str(), self.m_args.data());
+				return std::unexpected(error("execve failed", error(sys_error())));
+			},
+
+			[&] (fd const &file) {
+#if NIHIL_HAVE_FEXECVE == 1
+				::fexecv(file.get(), self.m_args.data());
+				return std::unexpected(error("execve failed", error(sys_error())));
+#else
+				std::ignore = file;
+				return std::unexpected(error(std::errc::function_not_supported));
+#endif
+			}
+		};
 	}
 
 private:
-	std::filesystem::path m_path;
+	// The thing we will execute.
+	std::variant<std::filesystem::path, fd> m_executable;
+	// Arguments to pass to the thing.
 	argv m_args;
 };
 
diff --git a/nihil.posix/execv.test.cc b/nihil.posix/execv.test.cc
index aaeead7..8c3ef0c 100644
--- a/nihil.posix/execv.test.cc
+++ b/nihil.posix/execv.test.cc
@@ -1,9 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.posix;
 
 namespace {
diff --git a/nihil.posix/execvp.ccm b/nihil.posix/execvp.ccm
index 270e311..14e548e 100644
--- a/nihil.posix/execvp.ccm
+++ b/nihil.posix/execvp.ccm
@@ -1,29 +1,26 @@
 // This source code is released into the public domain.
-module;
-
-#include <coroutine>
-#include <string>
-#include <expected>
-#include <format>
-
 export module nihil.posix:execvp;
 
+import nihil.std;
+import nihil.core;
 import nihil.error;
 import nihil.monad;
 import :argv;
 import :execv;
 import :find_in_path;
+import :open_in_path;
 
 namespace nihil {
 
-// execvp: equivalent to execv, except the command is passed as
-// a filename instead of a file descriptor.  If the filename is not
-// an absolute path, it will be searched for in $PATH.
+// execvp: equivalent to execv, except the command will be searched for in $PATH.
+
 export [[nodiscard]] auto
-execvp(std::string_view file, argv &&argv) -> std::expected<execv, error>
+execvp(std::filesystem::path const &file, argv &&args) -> std::expected<execv, error>
 {
-	auto filename = co_await find_in_path(file);
-	co_return execv(std::move(filename), std::move(argv));
+	if constexpr (features::fexecve)
+		co_return execv(co_await open_in_path(file), std::move(args));
+	else
+		co_return execv(co_await find_in_path(file), std::move(args));
 }
 
 } // namespace nihil
diff --git a/nihil.posix/execvp.test.cc b/nihil.posix/execvp.test.cc
index e34823d..5f1b979 100644
--- a/nihil.posix/execvp.test.cc
+++ b/nihil.posix/execvp.test.cc
@@ -2,6 +2,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.posix;
 
 namespace {
diff --git a/nihil.posix/fd.ccm b/nihil.posix/fd.ccm
index 7faf2f1..8210b6d 100644
--- a/nihil.posix/fd.ccm
+++ b/nihil.posix/fd.ccm
@@ -1,24 +1,23 @@
 // This source code is released into the public domain.
 module;
 
-#include <coroutine>
-#include <expected>
-#include <ranges>
-#include <span>
-#include <stdexcept>
-#include <system_error>
-
 #include <fcntl.h>
 #include <unistd.h>
 
 export module nihil.posix:fd;
 
+import nihil.std;
 import nihil.flagset;
 import nihil.error;
 import nihil.monad;
 
 namespace nihil {
 
+// Useful constants
+export inline int constexpr stdin_fileno = STDIN_FILENO;
+export inline int constexpr stdout_fileno = STDOUT_FILENO;
+export inline int constexpr stderr_fileno = STDERR_FILENO;
+
 // F_{GET,SET}FL flags
 struct fd_flags_tag
 {
@@ -96,7 +95,7 @@ export struct fd final
 		if (ret == 0)
 			return {};
 
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 	}
 
 	// Return the stored fd.
@@ -124,7 +123,7 @@ export struct fd final
 		if (ret >= 0)
 			return ret;
 
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 	}
 
 	// Read data from the fd to the provided buffer.  Returns a
@@ -136,7 +135,7 @@ export struct fd final
 		if (ret >= 0)
 			return buffer.subspan(0, ret);
 
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 	}
 
 private:
@@ -152,7 +151,7 @@ export [[nodiscard]] auto dup(fd const &self) -> std::expected<fd, error>
 	if (newfd != -1)
 		return fd(newfd);
 
-	return std::unexpected(error(std::errc(errno)));
+	return std::unexpected(error(sys_error()));
 }
 
 // Create a copy of this fd by calling dup2().  Note that because this results
@@ -170,7 +169,7 @@ export [[nodiscard]] auto dup(fd const &self, int newfd) -> std::expected<fd, er
 	if (ret != -1)
 		return fd(newfd);
 
-	return std::unexpected(error(std::errc(errno)));
+	return std::unexpected(error(sys_error()));
 }
 
 // Create a copy of this fd by calling dup().
@@ -180,7 +179,7 @@ export [[nodiscard]] auto raw_dup(fd const &self) -> std::expected<int, error>
 	if (newfd != -1)
 		return newfd;
 
-	return std::unexpected(error(std::errc(errno)));
+	return std::unexpected(error(sys_error()));
 }
 
 // Create a copy of this fd by calling dup2().
@@ -190,7 +189,7 @@ export [[nodiscard]] auto raw_dup(fd const &self, int newfd) -> std::expected<in
 	if (ret != -1)
 		return newfd;
 
-	return std::unexpected(error(std::errc(errno)));
+	return std::unexpected(error(sys_error()));
 }
 
 // Call fcntl() on this fd.  Prefer one of the type-safe wrappers to this, if available.
@@ -199,7 +198,7 @@ export [[nodiscard]] auto fcntl(fd const &fd, int op, int arg = 0)
 {
 	auto const ret = ::fcntl(fd.get(), op, arg);
 	if (ret == -1)
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 	return ret;
 }
 
@@ -277,7 +276,7 @@ export [[nodiscard]] auto pipe() -> std::expected<std::pair<fd, fd>, error>
 	auto fds = std::array<int, 2>{};
 
 	if (auto const ret = ::pipe(fds.data()); ret != 0)
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 
 	return {{fd(fds[0]), fd(fds[1])}};
 }
diff --git a/nihil.posix/fd.test.cc b/nihil.posix/fd.test.cc
index 870ddde..65b2ad3 100644
--- a/nihil.posix/fd.test.cc
+++ b/nihil.posix/fd.test.cc
@@ -1,15 +1,11 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <coroutine>
-#include <span>
-#include <stdexcept>
+// This source code is released into the public domain.
 
 #include <fcntl.h>
+#include <unistd.h>
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.error;
 import nihil.posix;
 
diff --git a/nihil.posix/fexecv.ccm b/nihil.posix/fexecv.ccm
deleted file mode 100644
index 4001726..0000000
--- a/nihil.posix/fexecv.ccm
+++ /dev/null
@@ -1,58 +0,0 @@
-// This source code is released into the public domain.
-module;
-
-#include <expected>
-#include <string>
-
-#include "nihil.hh"
-
-export module nihil.posix:fexecv;
-
-import nihil.error;
-import :argv;
-import :executor;
-import :fd;
-
-namespace nihil {
-
-#ifdef NIHIL_HAVE_FEXECVE
-
-/*
- * fexecv: use a file descriptor and an argument vector to call ::fexecve().
- * This is the lowest-level executor which all others are implemented
- * in terms of (if it's available).
- *
- * TODO: Should have a way to pass the environment (envp).
- */
-export struct fexecv final
-{
-	using tag = exec_tag;
-
-	fexecv(fd &&execfd, argv &&args) noexcept
-		: m_execfd(std::move(execfd))
-		, m_args(std::move(args))
-	{
-	}
-
-	[[nodiscard]] auto exec(this fexecv &self) -> std::expected<void, error>
-	{
-		::fexecve(self.m_execfd.get(), self.m_args.data(), environ);
-		return std::unexpected(error("fexecve failed", error(std::errc(errno))));
-	}
-
-	// Movable
-	fexecv(fexecv &&) noexcept = default;
-	auto operator=(this fexecv &, fexecv &&) noexcept -> fexecv & = default;
-
-	// Not copyable (because we hold the open fd object)
-	fexecv(fexecv const &) = delete;
-	auto operator=(this fexecv &, fexecv const &) -> fexecv & = delete;
-
-private:
-	fd m_execfd;
-	argv m_args;
-};
-
-#endif // NIHIL_HAVE_FEXECVE
-
-} // namespace nihil
diff --git a/nihil.posix/fexecvp.ccm b/nihil.posix/fexecvp.ccm
deleted file mode 100644
index d61240c..0000000
--- a/nihil.posix/fexecvp.ccm
+++ /dev/null
@@ -1,37 +0,0 @@
-// This source code is released into the public domain.
-module;
-
-#include <expected>
-#include <filesystem>
-#include <format>
-#include <string>
-
-#include "nihil.hh"
-
-export module nihil.posix:fexecvp;
-
-#ifdef NIHIL_HAVE_FEXECVE
-
-import nihil.error;
-import :argv;
-import :execv;
-import :open_in_path;
-
-namespace nihil {
-
-// execvp: equivalent to execv, except the command is passed as
-// a filename instead of a file descriptor.  If the filename is not
-// an absolute path, it will be searched for in $PATH.
-export [[nodiscard]] auto
-fexecvp(std::filesystem::path const &file, argv &&argv) -> std::expected<execv, error>
-{
-	auto execfd = open_in_path(file);
-	if (!execfd)
-		return std::unexpected(error(
-			std::format("executable not found in path: {}", file)));
-	return fexecv(std::move(*execfd), std::move(argv));
-}
-
-} // namespace nihil
-
-#endif	// NIHIL_HAVE_FEXECVE
diff --git a/nihil.posix/find_in_path.ccm b/nihil.posix/find_in_path.ccm
index 61df669..dabe358 100644
--- a/nihil.posix/find_in_path.ccm
+++ b/nihil.posix/find_in_path.ccm
@@ -1,19 +1,15 @@
 // This source code is released into the public domain.
 module;
 
-#include <expected>
-#include <filesystem>
-#include <optional>
-#include <ranges>
-
-#include <paths.h>
-#include <unistd.h>
+#include <unistd.h> // access()
 
 export module nihil.posix:find_in_path;
 
+import nihil.std;
 import nihil.error;
 import :fd;
 import :getenv;
+import :paths;
 
 namespace nihil {
 
@@ -28,7 +24,7 @@ export [[nodiscard]] auto find_in_path(std::filesystem::path const &file, std::s
 		auto ret = ::access(file.string().c_str(), X_OK);
 		if (ret == 0)
 			return {std::move(file)};
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 	};
 
 	// Absolute pathname skips the search.
@@ -59,7 +55,7 @@ export [[nodiscard]] auto find_in_path(std::filesystem::path const &file, std::s
 export [[nodiscard]] auto
 find_in_path(std::filesystem::path const &file) -> std::expected<std::filesystem::path, error>
 {
-	auto const path = getenv("PATH").value_or(_PATH_DEFPATH); // NOLINT
+	auto const path = getenv("PATH").value_or(std::string(paths::defpath)); // NOLINT
 	return find_in_path(file, path);
 }
 
diff --git a/nihil.posix/getenv.ccm b/nihil.posix/getenv.ccm
index 5967bf7..ddffeb3 100644
--- a/nihil.posix/getenv.ccm
+++ b/nihil.posix/getenv.ccm
@@ -2,18 +2,15 @@
 module;
 
 #include <cerrno>
-#include <expected>
-#include <string>
-#include <system_error>
-#include <vector>
-
-#include <unistd.h>
+#include <stdlib.h> // NOLINT: getenv_r
 
 #include "nihil.hh"
 
 export module nihil.posix:getenv;
 
+import nihil.std;
 import nihil.error;
+import nihil.util;
 
 namespace nihil {
 
@@ -23,9 +20,10 @@ namespace nihil {
 // future calls to setenv().
 export [[nodiscard]] auto getenv(std::string_view varname) -> std::expected<std::string, error>
 {
+	auto errno_guard = save_errno();
 	auto cvarname = std::string(varname);
 
-#ifdef NIHIL_HAVE_GETENV_R
+#if NIHIL_HAVE_GETENV_R == 1
 	// Start with a buffer of this size, and double it every iteration.
 	constexpr auto bufinc = std::size_t{1024};
 
@@ -44,16 +42,14 @@ export [[nodiscard]] auto getenv(std::string_view varname) -> std::expected<std:
 		return std::unexpected(error(std::errc(errno)));
 	}
 #else  // NIHIL_HAVE_GETENV_R
-	errno = 0;
-	auto *v = ::getenv(cvarname.c_str()); // NOLINT
+	// getenv() may not set errno on failure, so initialise it to a reasonable value.
+	errno = ENOENT;
+	auto const *v = ::getenv(cvarname.c_str()); // NOLINT
 
 	if (v != nullptr)
 		return {std::string(v)};
 
-	if (errno != 0)
-		return std::unexpected(error(std::errc(errno)));
-
-	return std::unexpected(error(std::errc::no_such_file_or_directory));
+	return error(sys_error());
 #endif // NIHIL_HAVE_GETENV_R
 }
 
diff --git a/nihil.posix/getenv.test.cc b/nihil.posix/getenv.test.cc
index 9e10c16..3ba1d94 100644
--- a/nihil.posix/getenv.test.cc
+++ b/nihil.posix/getenv.test.cc
@@ -1,18 +1,14 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <ranges>
-#include <string>
-#include <system_error>
+// This source code is released into the public domain.
 
 #include <unistd.h>
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.error;
 import nihil.posix;
 
+namespace {
 TEST_CASE("getenv: existing value", "[getenv]")
 {
 	auto constexpr *name = "NIHIL_TEST_VAR";
@@ -48,3 +44,5 @@ TEST_CASE("getenv: long value")
 	REQUIRE(s);
 	REQUIRE(*s == value);
 }
+
+} // anonymous namespace
diff --git a/nihil.posix/open.ccm b/nihil.posix/open.ccm
index 59f80af..f2f5ecd 100644
--- a/nihil.posix/open.ccm
+++ b/nihil.posix/open.ccm
@@ -1,20 +1,20 @@
 // This source code is released into the public domain.
 module;
 
-#include <expected>
-#include <filesystem>
-
 #include <fcntl.h>
 #include <unistd.h>
 
 export module nihil.posix:open;
 
+import nihil.std;
 import nihil.error;
 import nihil.flagset;
+import nihil.util;
 import :fd;
 
 namespace nihil {
 
+// Flags which can be passed to open().
 struct open_flags_tag
 {
 };
@@ -70,7 +70,7 @@ export [[nodiscard]] auto open(std::filesystem::path const &filename, open_flags
 	if (fdno != -1)
 		return fd(fdno);
 
-	return std::unexpected(error(std::errc(errno)));
+	return error(sys_error());
 }
 
 // Like open(), but resolve relative to an open file descriptor, which must refer to a directory.
@@ -81,7 +81,7 @@ export [[nodiscard]] auto openat(fd &where, std::filesystem::path const &filenam
 	if (fdno != -1)
 		return fd(fdno);
 
-	return std::unexpected(error(std::errc(errno)));
+	return error(sys_error());
 }
 
 } // namespace nihil
diff --git a/nihil.posix/open.test.cc b/nihil.posix/open.test.cc
index bb8bcc9..e49f4c4 100644
--- a/nihil.posix/open.test.cc
+++ b/nihil.posix/open.test.cc
@@ -2,6 +2,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.error;
 import nihil.posix;
 
diff --git a/nihil.posix/open_in_path.ccm b/nihil.posix/open_in_path.ccm
index e8c1761..0733c8d 100644
--- a/nihil.posix/open_in_path.ccm
+++ b/nihil.posix/open_in_path.ccm
@@ -1,20 +1,12 @@
 // This source code is released into the public domain.
-module;
-
-#include <expected>
-#include <filesystem>
-#include <optional>
-#include <ranges>
-#include <string>
-
-#include <paths.h>
-
 export module nihil.posix:open_in_path;
 
+import nihil.std;
 import nihil.error;
 import :fd;
 import :getenv;
 import :open;
+import :paths;
 
 namespace nihil {
 
@@ -51,7 +43,7 @@ open_in_path(std::filesystem::path const &file, std::string_view path) -> std::e
 export [[nodiscard]] auto
 open_in_path(std::filesystem::path const &file) -> std::expected<fd, error>
 {
-	auto const path = getenv("PATH").value_or(_PATH_DEFPATH); // NOLINT
+	auto const path = getenv("PATH").value_or(std::string(paths::defpath)); // NOLINT
 	return open_in_path(file, path);
 }
 
diff --git a/nihil.posix/open_in_path.test.cc b/nihil.posix/open_in_path.test.cc
index 13d6b49..ebd1405 100644
--- a/nihil.posix/open_in_path.test.cc
+++ b/nihil.posix/open_in_path.test.cc
@@ -2,6 +2,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.error;
 import nihil.posix;
 
diff --git a/nihil.posix/paths.ccm b/nihil.posix/paths.ccm
new file mode 100644
index 0000000..775e566
--- /dev/null
+++ b/nihil.posix/paths.ccm
@@ -0,0 +1,27 @@
+// This source code is released into the public domain.
+module;
+
+#include <paths.h>
+
+export module nihil.posix:paths;
+
+import nihil.std;
+
+namespace nihil::paths {
+
+export inline constexpr auto defpath = std::string_view(_PATH_DEFPATH);
+export inline constexpr auto stdpath = std::string_view(_PATH_STDPATH);
+
+#ifdef _PATH_LOCALBASE
+export inline constexpr auto localbase = std::string_view(_PATH_LOCALBASE);
+#else
+export inline constexpr auto localbase = std::string_view("/usr/local");
+#endif
+
+#ifdef _PATH_SYSPATH
+export inline constexpr auto syspath = std::string_view(_PATH_SYSPATH);
+#else
+export inline constexpr auto syspath = std::string_view("/sbin:/usr/sbin");
+#endif
+
+} // namespace nihil::paths
diff --git a/nihil.posix/posix.ccm b/nihil.posix/posix.ccm
index c49a992..aa21649 100644
--- a/nihil.posix/posix.ccm
+++ b/nihil.posix/posix.ccm
@@ -13,16 +13,16 @@ export import :execshell;
 export import :execv;
 export import :execvp;
 export import :fd;
-export import :fexecv;
-export import :fexecvp;
 export import :find_in_path;
 export import :getenv;
 export import :open;
 export import :open_in_path;
+export import :paths;
 export import :process;
 export import :read_file;
 export import :rename;
 export import :spawn;
 export import :stat;
 export import :tempfile;
+export import :unlink;
 export import :write_file;
diff --git a/nihil.posix/process.ccm b/nihil.posix/process.ccm
index ee7de15..9fbf34c 100644
--- a/nihil.posix/process.ccm
+++ b/nihil.posix/process.ccm
@@ -1,19 +1,17 @@
 // This source code is released into the public domain.
 module;
 
-#include <expected>
-#include <optional>
-#include <system_error>
-#include <utility>
-
 #include <sys/wait.h>
 
 export module nihil.posix:process;
 
+import nihil.std;
 import nihil.error;
 
 namespace nihil {
 
+export struct process;
+
 // wait_result: the exit status of a process.
 export struct wait_result final
 {
@@ -58,7 +56,7 @@ private:
 };
 
 // Represents a process we created, which can be waited for.
-export struct process final
+struct process final
 {
 	process() = delete;
 
@@ -83,7 +81,8 @@ export struct process final
 	// Movable.
 	process(process &&other) noexcept
 		: m_pid(std::exchange(other.m_pid, -1))
-	{}
+	{
+	}
 
 	auto operator=(this process &self, process &&other) noexcept -> process &
 	{
@@ -113,7 +112,7 @@ export struct process final
 		auto status = int{};
 		auto ret = waitpid(self.m_pid, &status, 0);
 		if (ret == -1)
-			return std::unexpected(error(std::errc(errno)));
+			return error(sys_error());
 
 		return wait_result(status);
 	}
diff --git a/nihil.posix/read_file.ccm b/nihil.posix/read_file.ccm
index 3b4fd5b..61c5085 100644
--- a/nihil.posix/read_file.ccm
+++ b/nihil.posix/read_file.ccm
@@ -1,20 +1,4 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <algorithm>
-#include <expected>
-#include <filesystem>
-#include <iterator>
-#include <ranges>
-#include <span>
-#include <system_error>
-
-#include <fcntl.h>
-#include <unistd.h>
-
+// This source code is released into the public domain.
 export module nihil.posix:read_file;
 
 import nihil.error;
@@ -24,12 +8,9 @@ import :open;
 
 namespace nihil {
 
-/*
- * Read the contents of a file into an output iterator. 
- */
+// Read the contents of a file into an output iterator.
 export [[nodiscard]] auto
-read_file(std::filesystem::path const &filename,
-	  std::output_iterator<char> auto &&iter)
+read_file(std::filesystem::path const &filename, std::output_iterator<char> auto &&iter)
 	-> std::expected<void, error>
 {
 	auto file = co_await open(filename, open_read);
@@ -38,7 +19,7 @@ read_file(std::filesystem::path const &filename,
 	auto buffer = std::array<char, bufsize>{};
 
 	for (;;) {
-		auto read_buf = co_await(read(file, buffer));
+		auto read_buf = co_await (read(file, buffer));
 		if (read_buf.empty())
 			co_return {};
 
diff --git a/nihil.posix/rename.ccm b/nihil.posix/rename.ccm
index a1b292e..c46005e 100644
--- a/nihil.posix/rename.ccm
+++ b/nihil.posix/rename.ccm
@@ -1,12 +1,9 @@
 // This source code is released into the public domain.
-module;
-
-#include <expected>
-#include <filesystem>
-
 export module nihil.posix:rename;
 
+import nihil.std;
 import nihil.error;
+import nihil.util;
 
 namespace nihil {
 
@@ -15,12 +12,11 @@ export [[nodiscard]] auto
 rename(std::filesystem::path const &oldp, std::filesystem::path const &newp)
 	-> std::expected<void, error>
 {
-	auto err = std::error_code();
-
-	std::filesystem::rename(oldp, newp, err);
+	auto guard = save_errno();
 
-	if (err)
-		return std::unexpected(error(err));
+	auto const ret = std::rename(oldp.string().c_str(), newp.string().c_str());
+	if (ret == -1)
+		return std::unexpected(error(sys_error()));
 
 	return {};
 }
diff --git a/nihil.posix/spawn.ccm b/nihil.posix/spawn.ccm
index a185bb3..1e4102a 100644
--- a/nihil.posix/spawn.ccm
+++ b/nihil.posix/spawn.ccm
@@ -1,52 +1,27 @@
 // This source code is released into the public domain.
-module;
-
-/*
- * spawn(): fork and execute a child process.
- */
-
-#include <algorithm>
-#include <cerrno>
-#include <coroutine>
-#include <expected>
-#include <filesystem>
-#include <format>
-#include <iterator>
-#include <print>
-#include <string>
-#include <utility>
-
-#include <sys/types.h>
-#include <sys/wait.h>
-
-#include <fcntl.h>
-#include <unistd.h>
-
 export module nihil.posix:spawn;
 
+// spawn(): fork and execute a child process.
+
 import nihil.monad;
 import :argv;
 import :executor;
+import :fd;
 import :open;
 import :process;
+import :unistd;
 
 namespace nihil {
 
-// Useful constants
-export inline int constexpr stdin_fileno = STDIN_FILENO;
-export inline int constexpr stdout_fileno = STDOUT_FILENO;
-export inline int constexpr stderr_fileno = STDERR_FILENO;
-
-/*
- * fd_{read,write}_pipe: create a pipe with one end in the child and the other in the parent.
- * The child's side will be dup2()'d to the provided fd number.
- * The parent side fd can be retrieved via parent_fd().
- *
- * fd_read_pipe() puts the reading side in the child, while fd_write_pipe() puts the writing
- * side in the child.
- */
+// fd_{read,write}_pipe: create a pipe with one end in the child and the other in the parent.
+// The child's side will be dup2()'d to the provided fd number.
+// The parent side fd can be retrieved via parent_fd().
+//
+// fd_read_pipe() puts the reading side in the child, while fd_write_pipe() puts the writing
+// side in the child.
 
-struct fd_pipe_base {
+struct fd_pipe_base
+{
 	fd_pipe_base(int fdno, fd &&child_fd, fd &&parent_fd)
 		: m_fdno(fdno)
 		, m_child_fd(std::move(child_fd))
@@ -58,8 +33,8 @@ struct fd_pipe_base {
 	{
 		auto err = raw_dup(self.m_child_fd, self.m_fdno);
 		if (!err) {
-			std::print("dup: {}\n", err.error());
-			_exit(1);
+			std::println("dup: {}", err.error());
+			std::quick_exit(1);
 		}
 
 		/*
@@ -81,35 +56,34 @@ struct fd_pipe_base {
 	}
 
 private:
-	int	m_fdno;
-	fd	m_child_fd;
-	fd	m_parent_fd;
-
+	int m_fdno;
+	fd m_child_fd;
+	fd m_parent_fd;
 };
 
-export struct fd_read_pipe final : fd_pipe_base {
+export struct fd_read_pipe final : fd_pipe_base
+{
 	fd_read_pipe(int fdno, fd &&read_fd, fd &&write_fd)
 		: fd_pipe_base(fdno, std::move(read_fd), std::move(write_fd))
 	{
 	}
 };
 
-export struct fd_write_pipe final : fd_pipe_base {
+export struct fd_write_pipe final : fd_pipe_base
+{
 	fd_write_pipe(int fdno, fd &&read_fd, fd &&write_fd)
 		: fd_pipe_base(fdno, std::move(write_fd), std::move(read_fd))
 	{
 	}
 };
 
-export [[nodiscard]] auto
-make_fd_read_pipe(int fdno) -> std::expected<fd_read_pipe, error>
+export [[nodiscard]] auto make_fd_read_pipe(int fdno) -> std::expected<fd_read_pipe, error>
 {
 	auto fds = co_await pipe();
 	co_return fd_read_pipe(fdno, std::move(fds.first), std::move(fds.second));
 }
 
-export [[nodiscard]] auto
-make_fd_write_pipe(int fdno) -> std::expected<fd_write_pipe, error>
+export [[nodiscard]] auto make_fd_write_pipe(int fdno) -> std::expected<fd_write_pipe, error>
 {
 	auto fds = co_await pipe();
 	co_return fd_write_pipe(fdno, std::move(fds.first), std::move(fds.second));
@@ -119,7 +93,8 @@ make_fd_write_pipe(int fdno) -> std::expected<fd_write_pipe, error>
  * fd_file: open a file and provide it to the child as a file descriptor.
  * open_flags and open_mode are as for ::open().
  */
-export struct fd_file final {
+export struct fd_file final
+{
 	fd_file(int fdno, fd &&file_fd)
 		: m_fdno(fdno)
 		, m_file_fd(std::move(file_fd))
@@ -136,20 +111,19 @@ export struct fd_file final {
 		auto err = raw_dup(self.m_file_fd, self.m_fdno);
 		if (!err) {
 			std::print("dup: {}\n", err.error());
-			_exit(1);
+			std::quick_exit(1);
 		}
 
 		std::ignore = self.m_file_fd.close();
 	}
 
 private:
-	int	m_fdno;
-	fd	m_file_fd;
+	int m_fdno;
+	fd m_file_fd;
 };
 
 export [[nodiscard]] auto
-make_fd_file(int fdno, std::filesystem::path const &file,
-	     open_flags flags, int mode = 0777)
+make_fd_file(int fdno, std::filesystem::path const &file, open_flags flags, int mode = 0777)
 	-> std::expected<fd_file, error>
 {
 	auto fd = co_await open(file, flags, mode);
@@ -160,20 +134,17 @@ make_fd_file(int fdno, std::filesystem::path const &file,
  * Shorthand for fd_file with /dev/null as the file.
  */
 
-export [[nodiscard]] inline auto
-stdin_devnull() -> std::expected<fd_file, error>
+export [[nodiscard]] inline auto stdin_devnull() -> std::expected<fd_file, error>
 {
 	return make_fd_file(stdin_fileno, "/dev/null", open_read);
 }
 
-export [[nodiscard]] inline auto
-stdout_devnull() -> std::expected<fd_file, error>
+export [[nodiscard]] inline auto stdout_devnull() -> std::expected<fd_file, error>
 {
 	return make_fd_file(stdout_fileno, "/dev/null", open_write);
 }
 
-export [[nodiscard]] inline auto 
-stderr_devnull() -> std::expected<fd_file, error>
+export [[nodiscard]] inline auto stderr_devnull() -> std::expected<fd_file, error>
 {
 	return make_fd_file(stderr_fileno, "/dev/null", open_write);
 }
@@ -182,8 +153,9 @@ stderr_devnull() -> std::expected<fd_file, error>
  * Capture the output of a pipe in the parent and read it into an
  * output iterator.
  */
-export template<std::output_iterator<char> Iterator>
-struct fd_capture final {
+export template <std::output_iterator<char> Iterator>
+struct fd_capture final
+{
 	fd_capture(fd_write_pipe &&pipe, Iterator it)
 		: m_pipe(std::move(pipe))
 		, m_iterator(std::move(it))
@@ -204,7 +176,7 @@ struct fd_capture final {
 		auto &fd = self.m_pipe.parent_fd();
 		for (;;) {
 			auto ret = read(fd, buffer);
-			if (!ret || ret->size() == 0)
+			if (!ret || ret->empty())
 				break;
 
 			std::ranges::copy(*ret, self.m_iterator);
@@ -215,21 +187,18 @@ struct fd_capture final {
 	}
 
 private:
-	fd_write_pipe	m_pipe;
-	Iterator	m_iterator;
+	fd_write_pipe m_pipe;
+	Iterator m_iterator;
 };
 
-export [[nodiscard]] auto
-make_capture(int fdno, std::output_iterator<char> auto &&it)
+export [[nodiscard]] auto make_capture(int fdno, std::output_iterator<char> auto &&it)
 	-> std::expected<fd_capture<decltype(it)>, error>
 {
 	auto pipe = co_await make_fd_write_pipe(fdno);
-	co_return fd_capture(std::move(pipe),
-			     std::forward<decltype(it)>(it));
+	co_return fd_capture(std::move(pipe), std::forward<decltype(it)>(it));
 }
 
-export [[nodiscard]] auto
-make_capture(int fdno, std::string &str)
+export [[nodiscard]] auto make_capture(int fdno, std::string &str)
 	-> std::expected<fd_capture<decltype(std::back_inserter(str))>, error>
 {
 	auto pipe = co_await make_fd_write_pipe(fdno);
@@ -241,14 +210,9 @@ make_capture(int fdno, std::string &str)
  * Throws exec_error() on failure.
  */
 export [[nodiscard]] auto
-spawn(executor auto &&executor, auto &&...actions)
-	-> std::expected<process, error>
+spawn(executor auto &&executor, auto &&...actions) -> std::expected<process, error>
 {
-	auto const pid = ::fork();
-	if (pid == -1)
-		return std::unexpected(error("fork failed",
-					     error(std::errc(errno))));
-
+	auto const pid = co_await fork();
 	auto proc = process(pid);
 
 	if (pid == 0) {
@@ -257,13 +221,13 @@ spawn(executor auto &&executor, auto &&...actions)
 		std::ignore = std::move(proc).release();
 
 		auto err = executor.exec();
-		std::print("{}\n", err.error());
-		_exit(1);
+		std::println("{}", err.error());
+		std::quick_exit(1);
 	}
 
 	(actions.run_in_parent(proc), ...);
 
-	return proc;
+	co_return proc;
 }
 
 } // namespace nihil
diff --git a/nihil.posix/stat.ccm b/nihil.posix/stat.ccm
index 6a0cabf..ee8113b 100644
--- a/nihil.posix/stat.ccm
+++ b/nihil.posix/stat.ccm
@@ -3,13 +3,12 @@ module;
 
 // Basic wrappers around stat() and fstat().
 
-#include <expected>
-#include <filesystem>
-
 #include <sys/stat.h>
 
 export module nihil.posix:stat;
 
+import nihil.std;
+import nihil.util;
 import :fd;
 
 namespace nihil {
@@ -17,19 +16,23 @@ namespace nihil {
 export [[nodiscard]] auto
 stat(std::filesystem::path const &path) -> std::expected<struct ::stat, error>
 {
+	auto guard = save_errno();
+
 	struct ::stat sb{};
 	auto ret = ::stat(path.string().c_str(), &sb);
 	if (ret == -1)
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 	return sb;
 }
 
 export [[nodiscard]] auto stat(fd const &fd) -> std::expected<struct ::stat, error>
 {
+	auto guard = save_errno();
+
 	struct ::stat sb{};
 	auto ret = ::fstat(fd.get(), &sb);
 	if (ret == -1)
-		return std::unexpected(error(std::errc(errno)));
+		return std::unexpected(error(sys_error()));
 	return sb;
 }
 
diff --git a/nihil.posix/stat.test.cc b/nihil.posix/stat.test.cc
index cf1e29c..535273b 100644
--- a/nihil.posix/stat.test.cc
+++ b/nihil.posix/stat.test.cc
@@ -1,5 +1,6 @@
 // This source code is released into the public domain.
 
+import nihil.std;
 import nihil.error;
 import nihil.posix;
 
diff --git a/nihil.posix/tempfile.ccm b/nihil.posix/tempfile.ccm
index e1510e5..121c636 100644
--- a/nihil.posix/tempfile.ccm
+++ b/nihil.posix/tempfile.ccm
@@ -1,22 +1,15 @@
 // This source code is released into the public domain.
-module;
-
-// tempfile: create a temporary file.
-
-#include <algorithm>
-#include <cstdint>
-#include <expected>
-#include <filesystem>
-#include <random>
-#include <string>
-
 export module nihil.posix:tempfile;
 
+import nihil.std;
 import nihil.error;
 import nihil.flagset;
 import :fd;
 import :getenv;
 import :open;
+import :unlink;
+
+// tempfile: create a temporary file.
 
 namespace nihil {
 
@@ -60,9 +53,7 @@ export struct temporary_file final
 			throw std::logic_error("release() called on already-released tempfile");
 
 		if (!self.m_path.empty()) {
-			auto ec = std::error_code(); // ignore errors
-			remove(self.path(), ec);
-
+			std::ignore = unlink(self.path());
 			self.m_path.clear();
 		}
 
@@ -141,8 +132,7 @@ tempfile(tempfile_flags flags = tempfile_none) -> std::expected<temporary_file,
 		}
 
 		if (flags & tempfile_unlink) {
-			auto ec = std::error_code();
-			remove(filename, ec);
+			std::ignore = unlink(filename);
 			return temporary_file(std::move(*fd));
 		}
 
diff --git a/nihil.posix/tempfile.test.cc b/nihil.posix/tempfile.test.cc
index b1c7604..fcaafdc 100644
--- a/nihil.posix/tempfile.test.cc
+++ b/nihil.posix/tempfile.test.cc
@@ -1,11 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <filesystem>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.posix;
 
 TEST_CASE("posix.tempfile: create", "[nihil][nihil.posix]")
diff --git a/nihil.posix/unistd.ccm b/nihil.posix/unistd.ccm
new file mode 100644
index 0000000..14c19ee
--- /dev/null
+++ b/nihil.posix/unistd.ccm
@@ -0,0 +1,23 @@
+// This source code is released into the public domain.
+module;
+
+#include <unistd.h>
+
+export module nihil.posix:unistd;
+
+import nihil.std;
+import nihil.error;
+
+// Symbols from unistd.h that might be useful.
+
+namespace nihil {
+
+export [[nodiscard]] auto fork() -> std::expected<::pid_t, error>
+{
+	auto const pid = ::fork();
+	if (pid == -1)
+		return std::unexpected(error(sys_error()));
+	return pid;
+}
+
+};
diff --git a/nihil.posix/unlink.ccm b/nihil.posix/unlink.ccm
new file mode 100644
index 0000000..d6c47cd
--- /dev/null
+++ b/nihil.posix/unlink.ccm
@@ -0,0 +1,28 @@
+// This source code is released into the public domain.
+module;
+
+#include <unistd.h>
+
+export module nihil.posix:unlink;
+
+// unlink: simple wrapper around ::unlink()
+
+import nihil.std;
+import nihil.error;
+import nihil.util;
+
+namespace nihil {
+
+export [[nodiscard]] auto unlink(std::filesystem::path const &path)
+	-> std::expected<void, error>
+{
+	auto guard = save_errno();
+
+	auto const ret = ::unlink(path.string().c_str());
+	if (ret == 0)
+		return {};
+
+	return std::unexpected(error(sys_error()));
+}
+
+} // namespace nihil
diff --git a/nihil.posix/write_file.ccm b/nihil.posix/write_file.ccm
index ce21e6b..4bdd6e2 100644
--- a/nihil.posix/write_file.ccm
+++ b/nihil.posix/write_file.ccm
@@ -1,34 +1,19 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <coroutine>
-#include <expected>
-#include <filesystem>
-#include <ranges>
-#include <system_error>
-#include <vector>
-
-#include <fcntl.h>
-#include <unistd.h>
-
+// This source code is released into the public domain.
 export module nihil.posix:write_file;
 
+import nihil.std;
 import nihil.error;
 import nihil.guard;
 import nihil.monad;
 import :fd;
 import :open;
 import :rename;
+import :unlink;
 
 namespace nihil {
 
-/*
- * Write the contents of a range to a file.  Returns the number of bytes
- * written.
- */
+// Write the contents of a range to a file.  Returns the number of bytes
+// written.
 export [[nodiscard]]
 auto write_file(std::filesystem::path const &filename,
 		std::ranges::contiguous_range auto &&range,
@@ -40,9 +25,7 @@ auto write_file(std::filesystem::path const &filename,
 	co_return nbytes;
 }
 
-/*
- * Utility wrapper for non-contiguous ranges.
- */
+// Utility wrapper for non-contiguous ranges.
 export [[nodiscard]]
 auto write_file(std::filesystem::path const &filename,
 		std::ranges::range auto &&range)
@@ -52,12 +35,10 @@ requires(!std::ranges::contiguous_range<decltype(range)>)
 	return write_file(filename, std::vector(std::from_range, range));
 }
 
-/*
- * Write the contents of a range to a file safely.  The data will be written
- * to "<filename>.tmp", and if the write succeeds, the temporary file will be
- * renamed to the target filename.  If an error occurs, the target file will
- * not be modified.
- */
+// Write the contents of a range to a file safely.  The data will be written
+// to "<filename>.tmp", and if the write succeeds, the temporary file will be
+// renamed to the target filename.  If an error occurs, the target file will
+// not be modified.
 export [[nodiscard]]
 auto safe_write_file(std::filesystem::path const &filename,
 		     std::ranges::range auto &&range)
@@ -68,11 +49,11 @@ auto safe_write_file(std::filesystem::path const &filename,
 	tmpfile /= (filename.filename().native() + ".tmp");
 
 	auto tmpfile_guard = guard([&tmpfile] {
-		::unlink(tmpfile.c_str());
+		std::ignore = unlink(tmpfile.c_str());
 	});
 
 	co_await write_file(tmpfile, range);
-	co_await nihil::rename(tmpfile, filename);
+	co_await rename(tmpfile, filename);
 
 	tmpfile_guard.release();
 	co_return {};
diff --git a/nihil.std/CMakeLists.txt b/nihil.std/CMakeLists.txt
new file mode 100644
index 0000000..27209a0
--- /dev/null
+++ b/nihil.std/CMakeLists.txt
@@ -0,0 +1,7 @@
+# This source code is released into the public domain.
+
+add_library(nihil.std STATIC)
+target_sources(nihil.std
+	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
+	nihil.std.ccm
+)
diff --git a/nihil.std/nihil.std.ccm b/nihil.std/nihil.std.ccm
new file mode 100644
index 0000000..2f01c91
--- /dev/null
+++ b/nihil.std/nihil.std.ccm
@@ -0,0 +1,429 @@
+// This source code is released into the public domain.
+module;
+
+// Export the parts of std that nihil uses.  This is technically undefined behaviour since we're
+// modifying namespace std, but this is essentially the same as what clang's own std.cppm does.
+// This module could be removed if/when we get support for std.cppm in both FreeBSD and CMake.
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <algorithm>
+#include <array>
+#include <charconv>
+#include <compare>
+#include <concepts>
+#include <coroutine>
+#include <exception>
+#include <expected>
+#include <filesystem>
+#include <format>
+#include <functional>
+#include <initializer_list>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <list>
+#include <locale>
+#include <map>
+#include <memory>
+#include <optional>
+#include <print>
+#include <random>
+#include <ranges>
+#include <set>
+#include <span>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <system_error>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <variant>
+#include <vector>
+
+export module nihil.std;
+
+// NOLINTBEGIN(misc-unused-using-decls,misc-unused-using-namespaces,misc-unused-alias-decls)
+
+export namespace std {
+// Symbols declared in multiple headers
+using std::operator+;
+using std::operator-;
+using std::operator|;
+using std::operator|=;
+using std::operator&;
+using std::operator&=;
+using std::operator^;
+using std::operator^=;
+using std::operator~;
+using std::operator<=>;
+using std::operator==;
+using std::operator!=;
+using std::operator<;
+using std::operator<=;
+using std::operator>;
+using std::operator>=;
+using std::operator<<;
+using std::operator>>;
+using std::operator<<=;
+using std::operator>>=;
+using std::swap;
+
+// <algorithm>
+using std::all_of;
+using std::copy;
+using std::fill;
+using std::fill_n;
+using std::find;
+using std::find_if;
+using std::find_if_not;
+using std::ranges::generate;
+using std::generate_n;
+using std::min;
+using std::max;
+
+namespace ranges {
+using std::ranges::all_of;
+using std::ranges::copy;
+using std::ranges::equal;
+using std::ranges::fill;
+using std::ranges::fill_n;
+using std::ranges::find;
+using std::ranges::find_if;
+using std::ranges::find_if_not;
+using std::ranges::generate;
+using std::ranges::generate_n;
+} // namespace ranges
+
+// <array>
+using std::array;
+
+// <charconv>
+using std::from_chars;
+using std::to_chars;
+using std::to_chars_result;
+using std::chars_format;
+
+// <compare>
+using std::partial_ordering;
+using std::strong_ordering;
+using std::cmp_equal;
+using std::cmp_greater;
+using std::cmp_greater_equal;
+using std::cmp_less;
+using std::cmp_less_equal;
+using std::cmp_not_equal;
+
+// <concepts>
+using std::convertible_to;
+using std::copy_constructible;
+using std::copy_constructible;
+using std::default_initializable;
+using std::derived_from;
+using std::destructible;
+using std::equality_comparable;
+using std::integral;
+using std::invocable;
+using std::move_constructible;
+using std::regular;
+using std::same_as;
+using std::semiregular;
+using std::swappable;
+using std::totally_ordered;
+
+// <coroutine>
+using std::coroutine_handle;
+using std::coroutine_traits;
+using std::noop_coroutine;
+using std::suspend_always;
+using std::suspend_never;
+
+// <cstddef>
+using std::byte;
+using std::ptrdiff_t;
+using std::size_t;
+using std::to_integer;
+
+// <cstdint>
+using std::int8_t;
+using std::int16_t;
+using std::int32_t;
+using std::int64_t;
+using std::uint8_t;
+using std::uint16_t;
+using std::uint32_t;
+using std::uint64_t;
+
+// <cstdlib>
+using std::exit;
+using std::quick_exit;
+
+// <cstdio>
+using std::FILE;
+using std::fprintf;
+using std::printf;
+using std::rename;
+
+// <cstring>
+using std::strerror;
+
+// <exception>
+using std::current_exception;
+using std::exception;
+using std::exception_ptr;
+using std::rethrow_exception;
+
+// <expected>
+using std::unexpected;
+using std::bad_expected_access;
+using std::unexpect;
+using std::unexpect_t;
+using std::expected;
+
+// <filesystem>
+namespace filesystem {
+using std::filesystem::path;
+using std::filesystem::create_directories;
+using std::filesystem::exists;
+}
+
+// <format>
+using std::format;
+using std::formatter;
+using std::format_to;
+using std::format_to_n;
+using std::runtime_format;
+using std::format_error;
+
+// <functional>
+using std::function;
+using std::invoke;
+using std::ref;
+using std::cref;
+using std::reference_wrapper;
+
+// <iostream>
+using std::cerr;
+using std::cin;
+using std::clog;
+using std::cout;
+using std::basic_ostream;
+using std::ostream;
+using std::istream;
+using std::basic_istream;
+using std::streambuf;
+using std::ostream_iterator;
+
+// <initializer_list>
+using std::initializer_list;
+
+// <iterator>
+using std::back_insert_iterator;
+using std::back_inserter;
+using std::input_iterator;
+using std::input_iterator_tag;
+using std::iter_value_t;
+using std::output_iterator;
+using std::sentinel_for;
+using std::next;
+using std::prev;
+using std::begin;
+using std::end;
+using std::distance;
+
+// <limits>
+using std::numeric_limits;
+
+// <list>
+using std::list;
+
+// <locale>
+using std::locale;
+using std::ctype;
+using std::ctype_base;
+using std::ctype_byname;
+using std::has_facet;
+using std::isalnum;
+using std::isalpha;
+using std::isblank;
+using std::iscntrl;
+using std::isdigit;
+using std::isgraph;
+using std::islower;
+using std::isprint;
+using std::ispunct;
+using std::isspace;
+using std::isupper;
+using std::isxdigit;
+using std::locale;
+using std::tolower;
+using std::toupper;
+using std::use_facet;
+
+// map
+using std::map;
+
+// <memory>
+using std::addressof;
+using std::allocator;
+using std::allocator_arg;
+using std::allocator_arg_t;
+using std::allocator_traits;
+using std::make_shared;
+using std::make_unique;
+using std::shared_ptr;
+using std::unique_ptr;
+
+// <optional>
+using std::nullopt;
+using std::optional;
+
+// <print>
+using std::print;
+using std::println;
+
+// <random>
+using std::default_random_engine;
+using std::random_device;
+using std::uniform_int_distribution;
+using std::mt19937;
+using std::ranlux24;;
+using std::ranlux24_base;
+using std::ranlux48;
+using std::ranlux48_base;
+
+using std::seed_seq;
+
+// <ranges>
+using std::from_range;
+using std::from_range_t;
+
+namespace ranges {
+using std::ranges::range_value_t;
+
+using std::ranges::contiguous_range;
+using std::ranges::enable_view;
+using std::ranges::range;
+using std::ranges::sized_range;
+
+using std::ranges::begin;
+using std::ranges::empty;
+using std::ranges::end;
+using std::ranges::data;
+using std::ranges::size;
+using std::ranges::rbegin;
+using std::ranges::rend;
+using std::ranges::subrange;
+
+using std::ranges::split_view;
+using std::ranges::transform_view;
+using std::ranges::operator|;
+
+namespace views {
+using std::ranges::views::split;
+using std::ranges::views::transform;
+} // namespace views
+
+} // namespace ranges
+
+namespace views = ranges::views;
+
+// <set>
+using std::set;
+
+// <span>
+using std::as_bytes;
+using std::as_writable_bytes;
+using std::dynamic_extent;
+using std::span;
+
+// <sstream>
+using std::basic_istringstream;
+using std::basic_ostringstream;
+using std::istringstream;
+using std::ostringstream;
+
+// <stdexcept>
+using std::logic_error;
+using std::runtime_error;
+using std::out_of_range;
+
+// <string>
+using std::basic_string;
+using std::basic_string_view;
+using std::char_traits;
+using std::string;
+using std::string_view;
+using std::wstring;
+using std::wstring_view;
+
+inline namespace literals {
+inline namespace string_literals {
+using std::literals::string_literals::operator""s;
+using std::literals::string_view_literals::operator""sv;
+}
+}
+
+// <system_error>
+using std::errc;
+using std::error_category;
+using std::error_code;
+using std::error_condition;
+using std::is_error_code_enum;
+using std::is_error_condition_enum;
+using std::make_error_code;
+using std::make_error_condition;
+using std::system_error;
+
+// <type_traits>
+using std::add_pointer_t;
+using std::false_type;
+using std::invoke_result;
+using std::is_convertible;
+using std::is_convertible_v;
+using std::is_default_constructible;
+using std::is_default_constructible_v;
+using std::is_nothrow_constructible;
+using std::is_nothrow_constructible_v;
+using std::is_nothrow_destructible;
+using std::is_nothrow_destructible_v;
+using std::is_nothrow_move_constructible;
+using std::is_nothrow_move_constructible_v;
+using std::is_reference;
+using std::is_reference_v;
+using std::is_same;
+using std::is_same_v;
+using std::remove_const_t;
+using std::remove_cv_t;
+using std::remove_cvref_t;
+using std::true_type;
+
+// <unordered_set>
+using std::unordered_set;
+
+// <utility>
+using std::exchange;
+using std::forward;
+using std::hash;
+using std::ignore;
+using std::make_pair;
+using std::move;
+using std::pair;
+
+// <variant>
+using std::get_if;
+using std::monostate;
+using std::variant;
+using std::visit;
+
+// <vector>
+using std::vector;
+
+} // namespace std
+
+// NOLINTEND(misc-unused-using-decls,misc-unused-using-namespaces,misc-unused-alias-decls)
diff --git a/nihil.ucl/CMakeLists.txt b/nihil.ucl/CMakeLists.txt
index 9d8ab3a..5b8ed72 100644
--- a/nihil.ucl/CMakeLists.txt
+++ b/nihil.ucl/CMakeLists.txt
@@ -3,13 +3,12 @@
 pkg_check_modules(LIBUCL REQUIRED libucl)
 
 add_library(nihil.ucl STATIC)
-target_link_libraries(nihil.ucl PRIVATE nihil.error nihil.monad)
+target_link_libraries(nihil.ucl PRIVATE nihil.std nihil.core nihil.error nihil.monad)
 
 target_sources(nihil.ucl
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	nihil.ucl.ccm
 	emit.ccm
-	errc.ccm
 	object.ccm
 	object_cast.ccm
 	parser.ccm
@@ -21,18 +20,6 @@ target_sources(nihil.ucl
 	map.ccm
 	real.ccm
 	string.ccm
-
-	PRIVATE
-	emit.cc
-	errc.cc
-	parser.cc
-	type.cc
-
-	object.cc
-	boolean.cc
-	integer.cc
-	real.cc
-	string.cc
 )
 
 target_compile_options(nihil.ucl PUBLIC ${LIBUCL_CFLAGS_OTHER})
@@ -41,6 +28,23 @@ target_link_libraries(nihil.ucl PUBLIC ${LIBUCL_LIBRARIES})
 target_link_directories(nihil.ucl PUBLIC ${LIBUCL_LIBRARY_DIRS})
 
 if(NIHIL_TESTS)
-	add_subdirectory(tests)
+	add_executable(nihil.ucl.test
+		array.test.cc
+		boolean.test.cc
+		emit.test.cc
+		integer.test.cc
+		map.test.cc
+		object.test.cc
+		parse.test.cc
+		real.test.cc
+		string.test.cc
+	)
+
+	target_link_libraries(nihil.ucl.test PRIVATE nihil.ucl Catch2::Catch2WithMain)
+
+	include(CTest)
+	include(Catch)
+	catch_discover_tests(nihil.ucl.test)
+
 	enable_testing()
 endif()
diff --git a/nihil.ucl/array.ccm b/nihil.ucl/array.ccm
index e3730ab..3d211d5 100644
--- a/nihil.ucl/array.ccm
+++ b/nihil.ucl/array.ccm
@@ -1,165 +1,119 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <cassert>
-#include <cerrno>
-#include <cstdint>
-#include <cstdlib>
-#include <format>
-#include <iostream>
-#include <string>
-#include <system_error>
-#include <utility>
-
 #include <ucl.h>
 
 export module nihil.ucl:array;
 
+import nihil.std;
 import :object;
 
 namespace nihil::ucl {
 
-export template<datatype T>
+export template <datatype T>
 struct array;
 
-export template<datatype T>
-struct array_iterator {
+//
+// The array iterator.  This is hardened, i.e. it always checks bounds.
+//
+export template <datatype T>
+struct array_iterator
+{
 	using difference_type = std::ptrdiff_t;
 	using value_type = T;
-	using reference = T&;
-	using pointer = T*;
+	using reference = T &;
+	using pointer = T *;
 
 	array_iterator() = default;
 
-	[[nodiscard]] auto operator* (this array_iterator const &self) -> T
+	// Return the value at this position.  We don't do type checking here
+	// since we assume that was done when the array was created or cast.
+	[[nodiscard]] auto operator*(this array_iterator const &self) -> T
 	{
 		auto arr = self.get_array();
 		if (self.m_idx >= ::ucl_array_size(arr))
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"access past end of array");
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "access past end of array");
 
 		auto uobj = ::ucl_array_find_index(arr, self.m_idx);
 		if (uobj == nullptr)
-			throw std::runtime_error(
-				"nihil::ucl::array_iterator: "
-				"failed to fetch UCL array index");
+			throw std::runtime_error("nihil::ucl::array_iterator: "
+			                         "failed to fetch UCL array index");
 
-		return T(nihil::ucl::ref, uobj);
+		return T(ref, uobj);
 	}
 
-	[[nodiscard]] auto operator[] (this array_iterator const &self,
-				       difference_type idx)
-		-> T
+	// Return the value at an offset.
+	[[nodiscard]] auto operator[](this array_iterator const &self, difference_type idx) -> T
 	{
 		return *(self + idx);
 	}
 
-	auto operator++ (this array_iterator &self) -> array_iterator &
+	// Advance this iterator.
+	auto operator++(this array_iterator &self) -> array_iterator &
 	{
 		auto arr = self.get_array();
+		// If we're already at end, don't allow going any further.
 		if (self.m_idx == ::ucl_array_size(arr))
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"iterating past end of array");
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "iterating past end of array");
 
 		++self.m_idx;
 		return self;
 	}
 
-	auto operator++ (this array_iterator &self, int) -> array_iterator
+	auto operator++(this array_iterator &self, int) -> array_iterator
 	{
 		auto copy = self;
 		++self;
 		return copy;
 	}
 
-	auto operator-- (this array_iterator &self) -> array_iterator&
+	auto operator--(this array_iterator &self) -> array_iterator &
 	{
 		if (self.m_idx == 0)
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"iterating before start of array");
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "iterating before start of array");
 		--self.m_idx;
 		return self;
 	}
 
-	auto operator-- (this array_iterator &self, int) -> array_iterator
+	auto operator--(this array_iterator &self, int) -> array_iterator
 	{
 		auto copy = self;
 		--self;
 		return copy;
 	}
 
-	[[nodiscard]] auto operator== (this array_iterator const &lhs,
-				       array_iterator const &rhs)
-		-> bool
-	{
-		// Empty iterators should compare equal.
-		if (lhs.m_array == nullptr && rhs.m_array == nullptr)
-			return true;
-
-		if (lhs.get_array() != rhs.get_array())
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"comparing iterators of different arrays");
-
-		return lhs.m_idx == rhs.m_idx;
-	}
-
-	[[nodiscard]] auto operator<=> (this array_iterator const &lhs,
-					array_iterator const &rhs)
-	{
-		// Empty iterators should compare equal.
-		if (lhs.m_array == nullptr && rhs.m_array == nullptr)
-			return std::strong_ordering::equal;
-
-		if (lhs.get_array() != rhs.get_array())
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"comparing iterators of different arrays");
-
-		return lhs.m_idx <=> rhs.m_idx;
-	}
-
-	auto operator+= (this array_iterator &lhs, difference_type rhs)
-		-> array_iterator &
+	auto operator+=(this array_iterator &lhs, difference_type rhs) -> array_iterator &
 	{
 		auto arr = lhs.get_array();
 		// m_idx cannot be greater than the array size
 		auto max_inc = ::ucl_array_size(arr) - lhs.m_idx;
 
 		if (std::cmp_greater(rhs, max_inc))
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"iterating past end of array");
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "iterating past end of array");
 
 		lhs.m_idx += rhs;
 		return lhs;
 	}
 
-	auto operator-= (this array_iterator &lhs, difference_type rhs)
-		-> array_iterator &
+	auto operator-=(this array_iterator &lhs, difference_type rhs) -> array_iterator &
 	{
 		if (std::cmp_greater(rhs, lhs.m_idx))
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"iterating before start of array");
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "iterating before start of array");
 		lhs.m_idx -= rhs;
 		return lhs;
 	}
 
-	[[nodiscard]] auto operator- (this array_iterator const &lhs,
-				      array_iterator const &rhs)
-		-> difference_type
+	[[nodiscard]] auto
+	operator-(this array_iterator const &lhs, array_iterator const &rhs) -> difference_type
 	{
 		if (lhs.get_array() != rhs.get_array())
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"comparing iterators of different arrays");
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "comparing iterators of different arrays");
 
 		return lhs.m_idx - rhs.m_idx;
 	}
@@ -167,146 +121,148 @@ struct array_iterator {
 private:
 	friend struct array<T>;
 
-	::ucl_object_t const *	m_array{};
-	std::size_t		m_idx{};
+	::ucl_object_t const *m_array{};
+	std::size_t           m_idx{};
 
-	[[nodiscard]] auto get_array(this array_iterator const &self)
-		-> ::ucl_object_t const *
+	[[nodiscard]] auto get_array(this array_iterator const &self) -> ::ucl_object_t const *
 	{
 		if (self.m_array == nullptr)
-			throw std::logic_error(
-				"nihil::ucl::array_iterator: "
-				"attempt to access an empty iterator");
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "attempt to access an empty iterator");
 
 		return self.m_array;
 	}
-		
-	array_iterator(::ucl_object_t const *array, std::size_t idx)
+
+	array_iterator(::ucl_object_t const *array, std::size_t const idx)
 		: m_array(array)
 		, m_idx(idx)
-	{}
-};
+	{
+	}
 
-export template<datatype T> [[nodiscard]]
-auto operator+(array_iterator<T> const &lhs,
-	       typename array_iterator<T>::difference_type rhs)
--> array_iterator<T>
-{
-	auto copy = lhs;
-	copy += rhs;
-	return copy;
-}
-
-export template<datatype T> [[nodiscard]]
-auto operator+(typename array_iterator<T>::difference_type lhs,
-	       array_iterator<T> const &rhs)
-	-> array_iterator<T>
-{
-	return rhs - lhs;
-}
+	[[nodiscard]] friend auto
+	operator==(array_iterator const &lhs, array_iterator const &rhs) -> bool
+	{
+		// Empty iterators should compare equal.
+		if (lhs.m_array == nullptr && rhs.m_array == nullptr)
+			return true;
 
-export template<datatype T> [[nodiscard]]
-auto operator-(array_iterator<T> const &lhs,
-	       typename array_iterator<T>::difference_type rhs)
-	-> array_iterator<T>
-{
-	auto copy = lhs;
-	copy -= rhs;
-	return copy;
-}
+		if (lhs.get_array() != rhs.get_array())
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "comparing iterators of different arrays");
 
-export template<datatype T = object>
-struct array final : object {
-	inline static constexpr object_type ucl_type = object_type::array;
+		return lhs.m_idx == rhs.m_idx;
+	}
+
+	[[nodiscard]] friend auto operator<=>(array_iterator const &lhs, array_iterator const &rhs)
+	{
+		// Empty iterators should compare equal.
+		if (lhs.m_array == nullptr && rhs.m_array == nullptr)
+			return std::strong_ordering::equal;
+
+		if (lhs.get_array() != rhs.get_array())
+			throw std::logic_error("nihil::ucl::array_iterator: "
+			                       "comparing iterators of different arrays");
+
+		return lhs.m_idx <=> rhs.m_idx;
+	}
+
+	[[nodiscard]] friend auto
+	operator+(array_iterator const &lhs, difference_type rhs) -> array_iterator
+	{
+		auto copy = lhs;
+		copy += rhs;
+		return copy;
+	}
+
+	[[nodiscard]] friend auto
+	operator+(difference_type lhs, array_iterator const &rhs) -> array_iterator
+	{
+		return rhs - lhs;
+	}
+
+	[[nodiscard]] friend auto
+	operator-(array_iterator const &lhs, difference_type rhs) -> array_iterator
+	{
+		auto copy = lhs;
+		copy -= rhs;
+		return copy;
+	}
+};
+
+export template <datatype T = object>
+struct array final : object
+{
+	static constexpr object_type ucl_type = object_type::array;
 
 	using value_type = T;
 	using size_type = std::size_t;
 	using difference_type = std::ptrdiff_t;
 	using iterator = array_iterator<T>;
 
-	/*
-	 * Create an empty array.  Throws std::system_error on failure.
-	 */
-	array()	: object(noref, [] {
+	// Movable.
+	array(array &&) noexcept = default;
+	auto operator=(array &&) noexcept -> array & = default;
+
+	// Copyable.  Note that this copies the entire UCL object.
+	array(array const &) = default;
+	auto operator=(array const &) -> array & = default;
+
+	~array() override = default;
+
+	// Create an empty array.  Throws std::system_error on failure.
+	array()
+		: object(noref, [] {
 			auto *uobj = ::ucl_object_typed_new(UCL_ARRAY);
 			if (uobj == nullptr)
-				throw std::system_error(
-					std::make_error_code(std::errc(errno)));
+				throw std::system_error(std::make_error_code(sys_error()));
 			return uobj;
 		}())
 	{
 	}
 
-	/*
-	 * Create an array from a UCL object.  Throws type_mismatch
-	 * on failure.
-	 *
-	 * Unlike object_cast<>, this does not check the type of the contained
-	 * elements, which means object access can throw type_mismatch.
-	 */
+	// Create an array from a UCL object.  Throws type_mismatch on failure.
+	//
+	// Unlike object_cast<>, this does not check the type of the contained
+	// elements, which means object access can throw type_mismatch.
 	array(ref_t, ::ucl_object_t const *uobj)
-		: object(nihil::ucl::ref, [&] {
-			auto actual_type = static_cast<object_type>(
-						::ucl_object_type(uobj));
-			if (actual_type != array::ucl_type)
-				throw type_mismatch(array::ucl_type,
-						    actual_type);
-			return uobj;
-		}())
+		: object(nihil::ucl::ref, ensure_ucl_type(uobj, array::ucl_type))
 	{
 	}
 
 	array(noref_t, ::ucl_object_t *uobj)
-		: object(nihil::ucl::noref, [&] {
-			auto actual_type = static_cast<object_type>(
-						::ucl_object_type(uobj));
-			if (actual_type != array::ucl_type)
-				throw type_mismatch(array::ucl_type,
-						    actual_type);
-			return uobj;
-		}())
+		: object(nihil::ucl::noref, ensure_ucl_type(uobj, array::ucl_type))
 	{
 	}
 
-	/*
-	 * Create an array from an iterator pair.
-	 */
-	template<std::input_iterator Iterator>
-	requires(std::convertible_to<std::iter_value_t<Iterator>, T>)
-	array(Iterator first, Iterator last)
-		 : array()
+	// Create an array from a range.
+	template <std::ranges::range Range>
+	requires(std::convertible_to<std::ranges::range_value_t<Range>, T>)
+	explicit array(Range const &range)
+		: array()
 	{
 		// This is exception safe, because if we throw here the
 		// base class destructor will free the array.
-		while (first != last) {
-			push_back(*first);
-			++first;
-		}
+		for (auto &&elm : range)
+			push_back(elm);
 	}
 
-	/*
-	 * Create an array from a range.
-	 */
-	template<std::ranges::range Range>
-	requires(std::convertible_to<std::ranges::range_value_t<Range>, T>)
-	array(std::from_range_t, Range &&range)
-		 : array(std::ranges::begin(range),
-			 std::ranges::end(range))
+	// Create an array from an iterator pair.
+	template <std::input_iterator Iterator>
+	requires(std::convertible_to<std::iter_value_t<Iterator>, T>)
+	array(Iterator first, Iterator last)
+		: array(std::ranges::subrange(first, last))
 	{
 	}
 
-	/*
-	 * Create an array from an initializer_list.
-	 */
+	// Create an array from an initializer_list.
 	array(std::initializer_list<T> const &list)
-		 : array(std::ranges::begin(list),
-			 std::ranges::end(list))
+		: array(std::ranges::subrange(list))
 	{
 	}
 
-	/*
-	 * Array iterator access.
-	 */
+	//
+	// Array iterator access.
+	//
 
 	[[nodiscard]] auto begin(this array const &self) -> iterator
 	{
@@ -318,133 +274,111 @@ struct array final : object {
 		return {self.get_ucl_object(), self.size()};
 	}
 
-	/*
-	 * Return the size of this array.
-	 */
+	// Return the size of this array.
 	[[nodiscard]] auto size(this array const &self) -> size_type
 	{
 		return ::ucl_array_size(self.get_ucl_object());
 	}
 
-	/*
-	 * Test if this array is empty.
-	 */
+	// Test if this array is empty.
 	[[nodiscard]] auto empty(this array const &self) -> bool
 	{
 		return self.size() == 0;
 	}
 
-	/*
-	 * Reserve space for future insertions.
-	 */
-	auto reserve(this array &self, size_type nelems) -> void
+	// Reserve space for future insertions.
+	auto reserve(this array &self, size_type const nelems) -> void
 	{
 		::ucl_object_reserve(self.get_ucl_object(), nelems);
 	}
 
-	/*
-	 * Append an element to the array.
-	 */
+	// Append an element to the array.
 	auto push_back(this array &self, value_type const &v) -> void
 	{
 		auto uobj = ::ucl_object_ref(v.get_ucl_object());
 		::ucl_array_append(self.get_ucl_object(), uobj);
 	}
 
-	/*
-	 * Prepend an element to the array.
-	 */
+	// Prepend an element to the array.
 	auto push_front(this array &self, value_type const &v) -> void
 	{
 		auto uobj = ::ucl_object_ref(v.get_ucl_object());
 		::ucl_array_prepend(self.get_ucl_object(), uobj);
 	}
 
-	/*
-	 * Access an array element by index.
-	 */
-	[[nodiscard]] auto at(this array const &self, size_type idx) -> T
+	// Access an array element by index.
+	[[nodiscard]] auto at(this array const &self, size_type const idx) -> T
 	{
 		if (idx >= self.size())
 			throw std::out_of_range("UCL array index out of range");
 
 		auto uobj = ::ucl_array_find_index(self.get_ucl_object(), idx);
 		if (uobj == nullptr)
-			throw std::runtime_error(
-				"failed to fetch UCL array index");
+			throw std::runtime_error("failed to fetch UCL array index");
 
 		return T(nihil::ucl::ref, uobj);
 	}
 
-	[[nodiscard]] auto operator[] (this array const &self, size_type idx) -> T
+	[[nodiscard]] auto operator[](this array const &self, size_type const idx) -> T
 	{
 		return self.at(idx);
 	}
 
-	/*
-	 * Return the first element.
-	 */
+	// Return the first element.
 	[[nodiscard]] auto front(this array const &self) -> T
 	{
 		return self.at(0);
 	}
 
-	/*
-	 * Return the last element.
-	 */
+	// Return the last element.
 	[[nodiscard]] auto back(this array const &self) -> T
 	{
 		if (self.empty())
 			throw std::out_of_range("attempt to access back() on "
-						"empty UCL array");
+			                        "empty UCL array");
 		return self.at(self.size() - 1);
 	}
-};
 
-/*
- * Comparison operators.
- */
-
-export template<datatype T> [[nodiscard]]
-auto operator==(array<T> const &a, array<T> const &b) -> bool
-{
-	if (a.size() != b.size())
-		return false;
+private:
+	//
+	// Comparison operators.
+	//
 
-	for (typename array<T>::size_type i = 0; i < a.size(); ++i)
-		if (a.at(i) != b.at(i))
+	[[nodiscard]] friend auto operator==(array const &a, array const &b) -> bool
+	{
+		if (a.size() != b.size())
 			return false;
 
-	return true;
-}
+		for (size_type i = 0; i < a.size(); ++i)
+			if (a.at(i) != b.at(i))
+				return false;
 
-/*
- * Print an array to an ostream; uses the same format as std::format().
- */
-export template<datatype T>
-auto operator<<(std::ostream &strm, array<T> const &a) -> std::ostream &
-{
-	return strm << std::format("{}", a);
-}
+		return true;
+	}
+
+	// Print an array to an ostream; uses the same format as std::format().
+	friend auto operator<<(std::ostream &strm, array const &a) -> std::ostream &
+	{
+		return strm << std::format("{}", a);
+	}
+};
 
 } // namespace nihil::ucl
 
-/*
- * std::formatter for an array.  The output format is a list of values
- * on a single line: [1, 2, 3].
- */
-export template<typename T>
+// std::formatter for an array.  The output format is a list of values
+// on a single line: [1, 2, 3].
+export template <typename T>
 struct std::formatter<nihil::ucl::array<T>, char>
 {
-	template<class ParseContext>
-	constexpr ParseContext::iterator parse(ParseContext& ctx)
+	template <class ParseContext>
+	constexpr auto parse(ParseContext &ctx) -> ParseContext::iterator
 	{
+		(void)this;
 		return ctx.begin();
 	}
 
-	template<class FmtContext>
-	FmtContext::iterator format(nihil::ucl::array<T> const &o,
-				    FmtContext& ctx) const
+	template <class FmtContext>
+	auto format(nihil::ucl::array<T> const &o, FmtContext &ctx) const -> FmtContext::iterator
 	{
 		auto it = ctx.out();
 		bool first = true;
diff --git a/nihil.ucl/tests/array.cc b/nihil.ucl/array.test.cc
index 866fa45..89394a0 100644
--- a/nihil.ucl/tests/array.cc
+++ b/nihil.ucl/array.test.cc
@@ -1,18 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <algorithm>
-#include <concepts>
-#include <expected>
-#include <ranges>
-#include <string>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 #include <ucl.h>
 
+import nihil.std;
 import nihil.ucl;
 
+namespace {
 TEST_CASE("ucl: array: invariants", "[ucl]")
 {
 	using namespace nihil::ucl;
@@ -27,42 +21,44 @@ TEST_CASE("ucl: array: invariants", "[ucl]")
 	static_assert(std::equality_comparable<array<>>);
 	static_assert(std::totally_ordered<array<>>);
 	static_assert(std::swappable<array<>>);
-	
+
 	static_assert(std::ranges::sized_range<array<integer>>);
-	static_assert(std::same_as<std::ranges::range_value_t<array<integer>>,
-				   integer>);
+	static_assert(std::same_as<std::ranges::range_value_t<array<integer>>, integer>);
 }
 
 TEST_CASE("ucl: array: constructor", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("default") {
+	SECTION("default")
+	{
 		auto arr = array<integer>();
 		REQUIRE(arr.size() == 0);
 		REQUIRE(str(arr.type()) == "array");
 	}
 
-	SECTION("from range") {
+	SECTION("from range")
+	{
 		auto vec = std::vector{integer(1), integer(42)};
-		auto arr = array<integer>(std::from_range, vec);
+		auto arr = array<integer>(vec);
 
 		REQUIRE(arr.size() == 2);
 		REQUIRE(arr[0] == 1);
 		REQUIRE(arr[1] == 42);
 	}
 
-	SECTION("from iterator pair") {
+	SECTION("from iterator pair")
+	{
 		auto vec = std::vector{integer(1), integer(42)};
-		auto arr = array<integer>(std::ranges::begin(vec),
-					  std::ranges::end(vec));
+		auto arr = array<integer>(std::ranges::begin(vec), std::ranges::end(vec));
 
 		REQUIRE(arr.size() == 2);
 		REQUIRE(arr[0] == 1);
 		REQUIRE(arr[1] == 42);
 	}
 
-	SECTION("from initializer_list") {
+	SECTION("from initializer_list")
+	{
 		auto arr = array<integer>{integer(1), integer(42)};
 
 		REQUIRE(arr.size() == 2);
@@ -75,9 +71,10 @@ TEST_CASE("ucl: array: construct from UCL object", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("ref, correct type") {
-		auto uarr = ::ucl_object_typed_new(UCL_ARRAY);
-		auto uint = ::ucl_object_fromint(42);
+	SECTION("ref, correct type")
+	{
+		auto *uarr = ::ucl_object_typed_new(UCL_ARRAY);
+		auto *uint = ::ucl_object_fromint(42);
 		::ucl_array_append(uarr, uint);
 
 		auto arr = array<integer>(ref, uarr);
@@ -86,34 +83,38 @@ TEST_CASE("ucl: array: construct from UCL object", "[ucl]")
 		::ucl_object_unref(uarr);
 	}
 
-	SECTION("noref, correct type") {
-		auto uarr = ::ucl_object_typed_new(UCL_ARRAY);
-		auto uint = ::ucl_object_fromint(42);
+	SECTION("noref, correct type")
+	{
+		auto *uarr = ::ucl_object_typed_new(UCL_ARRAY);
+		auto *uint = ::ucl_object_fromint(42);
 		::ucl_array_append(uarr, uint);
 
 		auto arr = array<integer>(noref, uarr);
 		REQUIRE(arr[0] == 42);
 	}
 
-	SECTION("ref, wrong element type") {
-		auto uarr = ::ucl_object_typed_new(UCL_ARRAY);
-		auto uint = ::ucl_object_frombool(true);
+	SECTION("ref, wrong element type")
+	{
+		auto *uarr = ::ucl_object_typed_new(UCL_ARRAY);
+		auto *uint = ::ucl_object_frombool(true);
 		::ucl_array_append(uarr, uint);
 
 		auto arr = array<integer>(noref, uarr);
 		REQUIRE_THROWS_AS(arr[0], type_mismatch);
 	}
 
-	SECTION("ref, wrong type") {
-		auto uobj = ::ucl_object_frombool(true);
+	SECTION("ref, wrong type")
+	{
+		auto *uobj = ::ucl_object_frombool(true);
 
 		REQUIRE_THROWS_AS(array(ref, uobj), type_mismatch);
 
 		::ucl_object_unref(uobj);
 	}
 
-	SECTION("noref, wrong type") {
-		auto uobj = ::ucl_object_frombool(true);
+	SECTION("noref, wrong type")
+	{
+		auto *uobj = ::ucl_object_frombool(true);
 
 		REQUIRE_THROWS_AS(array(noref, uobj), type_mismatch);
 
@@ -125,10 +126,8 @@ TEST_CASE("ucl: array: swap", "[ucl]")
 {
 	// do not add using namespace nihil::ucl
 
-	auto arr1 = nihil::ucl::array<nihil::ucl::integer>{
-		nihil::ucl::integer(1),
-		nihil::ucl::integer(2)
-	};
+	auto arr1 = nihil::ucl::array<nihil::ucl::integer>{nihil::ucl::integer(1),
+	                                                   nihil::ucl::integer(2)};
 
 	auto arr2 = nihil::ucl::array<nihil::ucl::integer>{
 		nihil::ucl::integer(3),
@@ -169,9 +168,7 @@ TEST_CASE("ucl: array: compare", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	auto arr = array<integer>{
-		integer(1), integer(42), integer(666)
-	};
+	auto arr = array<integer>{integer(1), integer(42), integer(666)};
 
 	auto arr2 = array<integer>();
 	REQUIRE(arr != arr2);
@@ -181,9 +178,7 @@ TEST_CASE("ucl: array: compare", "[ucl]")
 	arr2.push_back(integer(666));
 	REQUIRE(arr == arr2);
 
-	auto arr3 = array<integer>{
-		integer(1), integer(1), integer(1)
-	};
+	auto arr3 = array<integer>{integer(1), integer(1), integer(1)};
 
 	REQUIRE(arr != arr3);
 }
@@ -237,33 +232,33 @@ TEST_CASE("ucl: array: emit", "[ucl]")
 	auto ucl = parse("array = [1, 42, 666];").value();
 
 	auto output = std::format("{:c}", ucl);
-	REQUIRE(output == 
-"array [\n"
-"    1,\n"
-"    42,\n"
-"    666,\n"
-"]\n");
+	REQUIRE(output == "array [\n"
+	                  "    1,\n"
+	                  "    42,\n"
+	                  "    666,\n"
+	                  "]\n");
 }
 
 TEST_CASE("ucl: array: format", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("empty array") {
+	SECTION("empty array")
+	{
 		auto arr = array<integer>();
 		REQUIRE(std::format("{}", arr) == "[]");
 	}
 
-	SECTION("bare array") {
-		auto arr = array<integer>{
-			integer(1), integer(42), integer(666)
-		};
+	SECTION("bare array")
+	{
+		auto arr = array<integer>{integer(1), integer(42), integer(666)};
 
 		auto output = std::format("{}", arr);
 		REQUIRE(output == "[1, 42, 666]");
 	}
 
-	SECTION("parsed array") {
+	SECTION("parsed array")
+	{
 		auto ucl = parse("array = [1, 42, 666];").value();
 		auto arr = object_cast<array<integer>>(ucl["array"]).value();
 
@@ -276,7 +271,8 @@ TEST_CASE("ucl: array: print to ostream", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("empty array") {
+	SECTION("empty array")
+	{
 		auto arr = array<integer>();
 		auto strm = std::ostringstream();
 		strm << arr;
@@ -284,17 +280,17 @@ TEST_CASE("ucl: array: print to ostream", "[ucl]")
 		REQUIRE(strm.str() == "[]");
 	}
 
-	SECTION("bare array") {
-		auto arr = array<integer>{
-			integer(1), integer(42), integer(666)
-		};
+	SECTION("bare array")
+	{
+		auto arr = array<integer>{integer(1), integer(42), integer(666)};
 		auto strm = std::ostringstream();
 		strm << arr;
 
 		REQUIRE(strm.str() == "[1, 42, 666]");
 	}
 
-	SECTION("parsed array") {
+	SECTION("parsed array")
+	{
 		auto ucl = parse("array = [1, 42, 666];").value();
 		auto arr = object_cast<array<integer>>(ucl["array"]).value();
 		auto strm = std::ostringstream();
@@ -325,12 +321,10 @@ TEST_CASE("ucl: array is a sized_range", "[ucl]")
 	std::ranges::copy(arr, std::back_inserter(vec));
 	REQUIRE(std::ranges::equal(arr, vec));
 
-	auto arr_as_ints =
-		arr | std::views::transform(&integer::value);
+	auto arr_as_ints = arr | std::views::transform(&integer::value);
 	auto int_vec = std::vector<integer::contained_type>();
 	std::ranges::copy(arr_as_ints, std::back_inserter(int_vec));
 	REQUIRE(int_vec == std::vector<std::int64_t>{1, 42, 666});
-
 }
 
 TEST_CASE("ucl: array: bad object_cast", "[ucl]")
@@ -435,16 +429,18 @@ TEST_CASE("array iterator: invalid operations", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	auto arr = array<integer>{ integer(42) };
+	auto arr = array<integer>{integer(42)};
 	auto it = arr.begin();
 
-	SECTION("decrement before start") {
+	SECTION("decrement before start")
+	{
 		REQUIRE_THROWS_AS(--it, std::logic_error);
 		REQUIRE_THROWS_AS(it--, std::logic_error);
 		REQUIRE_THROWS_AS(it - 1, std::logic_error);
 	}
 
-	SECTION("increment past end") {
+	SECTION("increment past end")
+	{
 		++it;
 		REQUIRE(it == arr.end());
 
@@ -453,7 +449,8 @@ TEST_CASE("array iterator: invalid operations", "[ucl]")
 		REQUIRE_THROWS_AS(it + 1, std::logic_error);
 	}
 
-	SECTION("dereference iterator at end") {
+	SECTION("dereference iterator at end")
+	{
 		REQUIRE_THROWS_AS(it[1], std::logic_error);
 
 		++it;
@@ -462,17 +459,21 @@ TEST_CASE("array iterator: invalid operations", "[ucl]")
 		REQUIRE_THROWS_AS(*it, std::logic_error);
 	}
 
-	SECTION("compare with different array") {
-		auto arr2 = array<integer>{ integer(42) };
+	SECTION("compare with different array")
+	{
+		auto arr2 = array<integer>{integer(42)};
 		REQUIRE_THROWS_AS(it == arr2.begin(), std::logic_error);
 		REQUIRE_THROWS_AS(it > arr2.begin(), std::logic_error);
 		REQUIRE_THROWS_AS(it - arr2.begin(), std::logic_error);
 	}
 
-	SECTION("compare with empty iterator") {
+	SECTION("compare with empty iterator")
+	{
 		auto it2 = array_iterator<integer>();
 		REQUIRE_THROWS_AS(it == it2, std::logic_error);
 		REQUIRE_THROWS_AS(it > it2, std::logic_error);
 		REQUIRE_THROWS_AS(it - it2, std::logic_error);
 	}
 }
+
+} // anonymous namespace
diff --git a/nihil.ucl/boolean.cc b/nihil.ucl/boolean.cc
deleted file mode 100644
index 91f2b17..0000000
--- a/nihil.ucl/boolean.cc
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <compare>
-#include <cstdlib>
-#include <expected>
-#include <system_error>
-
-#include <ucl.h>
-
-module nihil.ucl;
-
-import nihil.error;
-
-namespace nihil::ucl {
-
-auto make_boolean(boolean::contained_type value)
-	-> std::expected<boolean, error>
-{
-	auto *uobj = ::ucl_object_frombool(value);
-	if (uobj == nullptr)
-		return std::unexpected(error(
-			errc::failed_to_create_object,
-			error(std::errc(errno))));
-
-	return boolean(noref, uobj);
-}
-
-boolean::boolean()
-	: boolean(false)
-{
-}
-
-boolean::boolean(contained_type value)
-	: object(noref, [&] {
-		auto *uobj = ::ucl_object_frombool(value);
-		if (uobj == nullptr)
-			throw std::system_error(
-				std::make_error_code(std::errc(errno)));
-		return uobj;
-	}())
-{
-}
-
-boolean::boolean(ref_t, ::ucl_object_t const *uobj)
-	: object(nihil::ucl::ref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != boolean::ucl_type)
-			throw type_mismatch(boolean::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-boolean::boolean(noref_t, ::ucl_object_t *uobj)
-	: object(nihil::ucl::noref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != boolean::ucl_type)
-			throw type_mismatch(boolean::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-auto boolean::value(this boolean const &self)
-	-> contained_type
-{
-	auto v = contained_type{};
-	auto const *uobj = self.get_ucl_object();
-
-	if (::ucl_object_toboolean_safe(uobj, &v))
-		return v;
-
-	std::abort();
-}
-
-auto operator== (boolean const &a, boolean const &b)
-	-> bool
-{
-	return a.value() == b.value();
-}
-
-auto operator<=> (boolean const &a, boolean const &b)
-	-> std::strong_ordering
-{
-	return a.value() <=> b.value();
-}
-
-auto operator== (boolean const &a, boolean::contained_type b)
-	-> bool
-{
-	return a.value() == b;
-}
-
-auto operator<=> (boolean const &a, boolean::contained_type b)
-	-> std::strong_ordering
-{
-	return a.value() <=> b;
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/boolean.ccm b/nihil.ucl/boolean.ccm
index 068dfdd..4cacdc4 100644
--- a/nihil.ucl/boolean.ccm
+++ b/nihil.ucl/boolean.ccm
@@ -1,90 +1,118 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <expected>
-#include <format>
-#include <string>
-
 #include <ucl.h>
 
 export module nihil.ucl:boolean;
 
+import nihil.std;
+import nihil.core;
 import :object;
 
 namespace nihil::ucl {
 
-export struct boolean final : object {
+export struct boolean final : object
+{
 	using contained_type = bool;
 
-	inline static constexpr object_type ucl_type = object_type::boolean;
+	static constexpr object_type ucl_type = object_type::boolean;
+
+	// Create a boolean holding the value false.  Throws std::system_error
+	// on failure.
+	boolean()
+		: boolean(false)
+	{
+	}
+
+	// Create a boolean holding a specific value.  Throws std::system_error
+	// on failure.
+	explicit boolean(bool const value)
+		: object(noref, [&] {
+			auto *uobj = ::ucl_object_frombool(value);
+			if (uobj == nullptr)
+				throw std::system_error(std::make_error_code(sys_error()));
+			return uobj;
+		}())
+	{
+	}
 
-	/*
-	 * Create a boolean holding the value false.  Throws std::system_error
-	 * on failure.
-	 */
-	boolean();
+	// Create a new boolean from a UCL object.  Throws type_mismatch
+	// on failure.
 
-	/*
-	 * Create a boolean holding a specific value.  Throws std::system_error
-	 * on failure.
-	 */
-	explicit boolean(bool);
+	boolean(ref_t, ::ucl_object_t const *uobj)
+		: object(nihil::ucl::ref, ensure_ucl_type(uobj, boolean::ucl_type))
+	{
+	}
 
-	/*
-	 * Create a new boolean from a UCL object.  Throws type_mismatch
-	 * on failure.
-	 */
-	boolean(ref_t, ::ucl_object_t const *uobj);
-	boolean(noref_t, ::ucl_object_t *uobj);
+	boolean(noref_t, ::ucl_object_t *uobj)
+		: object(nihil::ucl::noref, ensure_ucl_type(uobj, boolean::ucl_type))
+	{
+	}
 
 	// Return this object's value.
-	auto value(this boolean const &self) -> contained_type;
-};
+	auto value(this boolean const &self) -> contained_type
+	{
+		auto        v = contained_type{};
+		auto const *uobj = self.get_ucl_object();
 
-/*
- * Boolean constructors.  These return an error instead of throwing.
- */
+		if (::ucl_object_toboolean_safe(uobj, &v))
+			return v;
 
-export [[nodiscard]] auto
-make_boolean(boolean::contained_type = false) -> std::expected<boolean, error>;
+		throw std::runtime_error("ucl_object_toboolean_safe failed");
+	}
+
+private:
+	// Comparison operators.
+	[[nodiscard]] friend auto operator==(boolean const &a, boolean const &b) -> bool
+	{
+		return a.value() == b.value();
+	}
 
-/*
- * Comparison operators.
- */
+	[[nodiscard]] friend auto
+	operator<=>(boolean const &a, boolean const &b) -> std::strong_ordering
+	{
+		return static_cast<int>(a.value()) <=> static_cast<int>(b.value());
+	}
 
-export auto operator== (boolean const &a, boolean const &b) -> bool;
-export auto operator== (boolean const &a, boolean::contained_type b) -> bool;
-export auto operator<=> (boolean const &a, boolean const &b)
-	-> std::strong_ordering;
-export auto operator<=> (boolean const &a, boolean::contained_type b)
-	-> std::strong_ordering;
+	[[nodiscard]] friend auto operator==(boolean const &a, contained_type const b) -> bool
+	{
+		return a.value() == b;
+	}
+
+	[[nodiscard]] friend auto
+	operator<=>(boolean const &a, contained_type const b) -> std::strong_ordering
+	{
+		return static_cast<int>(a.value()) <=> static_cast<int>(b);
+	}
+};
+
+// Boolean constructors.  This returns an error instead of throwing.
+export [[nodiscard]] auto
+make_boolean(boolean::contained_type const value = false) -> std::expected<boolean, error>
+{
+	if (auto *uobj = ::ucl_object_frombool(value); uobj == nullptr)
+		return error(errc::failed_to_create_object, error(sys_error()));
+	else
+		return boolean(noref, uobj);
+}
 
 } // namespace nihil::ucl
 
-/*
- * std::formatter for a boolean.  This provides the same format operations
- * as std::formatter<bool>.
- */
-export template<>
+// std::formatter for a boolean.  This provides the same format operations
+// as std::formatter<bool>.
+export template <>
 struct std::formatter<nihil::ucl::boolean, char>
 {
 	std::formatter<bool> base_formatter;
 
-	template<class ParseContext>
-	constexpr ParseContext::iterator parse(ParseContext& ctx)
+	template <class ParseContext>
+	constexpr auto parse(ParseContext &ctx) -> ParseContext::iterator
 	{
 		return base_formatter.parse(ctx);
 	}
 
-	template<class FmtContext>
-	FmtContext::iterator format(nihil::ucl::boolean const &o,
-				    FmtContext& ctx) const
+	template <class FmtContext>
+	auto format(nihil::ucl::boolean const &o, FmtContext &ctx) const -> FmtContext::iterator
 	{
 		return base_formatter.format(o.value(), ctx);
 	}
diff --git a/nihil.ucl/tests/boolean.cc b/nihil.ucl/boolean.test.cc
index f7ef95e..9fb0148 100644
--- a/nihil.ucl/tests/boolean.cc
+++ b/nihil.ucl/boolean.test.cc
@@ -1,16 +1,15 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <concepts>
-#include <string>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 #include <ucl.h>
 
+import nihil.std;
 import nihil.ucl;
 
-TEST_CASE("ucl: boolean: invariants", "[ucl]")
+namespace {
+inline auto constexpr *test_tags = "[nihil][nihil.ucl][nihil.ucl.boolean]";
+
+TEST_CASE("ucl: boolean: invariants", test_tags)
 {
 	using namespace nihil::ucl;
 
@@ -27,18 +26,24 @@ TEST_CASE("ucl: boolean: invariants", "[ucl]")
 	static_assert(std::swappable<boolean>);
 }
 
-TEST_CASE("ucl: boolean: constructor", "[ucl]")
+SCENARIO("Constructing a ucl::boolean", test_tags)
 {
 	using namespace nihil::ucl;
 
-	SECTION("default") {
+	GIVEN ("A default-constructed boolean") {
 		auto b = boolean();
-		REQUIRE(b == false);
+
+		THEN ("The value is false") {
+			REQUIRE(b == false);
+		}
 	}
 
-	SECTION("with value") {
+	GIVEN ("A boolean constructed from a true value") {
 		auto b = boolean(true);
-		REQUIRE(b == true);
+
+		THEN ("The value is true") {
+			REQUIRE(b == true);
+		}
 	}
 }
 
@@ -46,8 +51,9 @@ TEST_CASE("ucl: boolean: construct from UCL object", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("ref, correct type") {
-		auto uobj = ::ucl_object_frombool(true);
+	SECTION("ref, correct type")
+	{
+		auto *uobj = ::ucl_object_frombool(true);
 
 		auto i = boolean(ref, uobj);
 		REQUIRE(i == true);
@@ -55,23 +61,26 @@ TEST_CASE("ucl: boolean: construct from UCL object", "[ucl]")
 		::ucl_object_unref(uobj);
 	}
 
-	SECTION("noref, correct type") {
-		auto uobj = ::ucl_object_frombool(true);
+	SECTION("noref, correct type")
+	{
+		auto *uobj = ::ucl_object_frombool(true);
 
 		auto i = boolean(noref, uobj);
 		REQUIRE(i == true);
 	}
 
-	SECTION("ref, wrong type") {
-		auto uobj = ::ucl_object_fromint(1);
+	SECTION("ref, wrong type")
+	{
+		auto *uobj = ::ucl_object_fromint(1);
 
 		REQUIRE_THROWS_AS(boolean(ref, uobj), type_mismatch);
 
 		::ucl_object_unref(uobj);
 	}
 
-	SECTION("noref, wrong type") {
-		auto uobj = ::ucl_object_fromint(1);
+	SECTION("noref, wrong type")
+	{
+		auto *uobj = ::ucl_object_fromint(1);
 
 		REQUIRE_THROWS_AS(boolean(noref, uobj), type_mismatch);
 
@@ -83,12 +92,14 @@ TEST_CASE("ucl: boolean: make_boolean", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("default value") {
+	SECTION("default value")
+	{
 		auto b = make_boolean().value();
 		REQUIRE(b == false);
 	}
 
-	SECTION("explicit value") {
+	SECTION("explicit value")
+	{
 		auto b = make_boolean(true).value();
 		REQUIRE(b == true);
 	}
@@ -97,7 +108,7 @@ TEST_CASE("ucl: boolean: make_boolean", "[ucl]")
 TEST_CASE("ucl: boolean: swap", "[ucl]")
 {
 	// do not add using namespace nihil::ucl
-	
+
 	auto b1 = nihil::ucl::boolean(true);
 	auto b2 = nihil::ucl::boolean(false);
 
@@ -117,14 +128,11 @@ TEST_CASE("ucl: boolean: key()", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	auto err = parse("a_bool = true");
-	REQUIRE(err);
-
-	auto obj = *err;
-	REQUIRE(object_cast<boolean>(obj["a_bool"])->key() == "a_bool");
+	auto obj = parse("a_bool = true").value();
+	REQUIRE(object_cast<boolean>(obj["a_bool"]).value().key() == "a_bool");
 
-	auto b = nihil::ucl::boolean(true);
-	REQUIRE(b.key() == "");
+	auto b = boolean(true);
+	REQUIRE(b.key().empty() == true);
 }
 
 TEST_CASE("ucl: boolean: comparison", "[ucl]")
@@ -133,22 +141,26 @@ TEST_CASE("ucl: boolean: comparison", "[ucl]")
 
 	auto b = boolean(true);
 
-	SECTION("operator==") {
+	SECTION("operator==")
+	{
 		REQUIRE(b == true);
 		REQUIRE(b == boolean(true));
 	}
 
-	SECTION("operator!=") {
+	SECTION("operator!=")
+	{
 		REQUIRE(b != false);
 		REQUIRE(b != boolean(false));
 	}
 
-	SECTION("operator<") {
+	SECTION("operator<")
+	{
 		REQUIRE(b <= true);
 		REQUIRE(b <= nihil::ucl::boolean(true));
 	}
 
-	SECTION("operator>") {
+	SECTION("operator>")
+	{
 		REQUIRE(b > false);
 		REQUIRE(b > nihil::ucl::boolean(false));
 	}
@@ -172,8 +184,7 @@ TEST_CASE("ucl: boolean: parse and emit", "[ucl]")
 	auto ucl = parse("bool = true;").value();
 
 	auto output = std::string();
-	emit(ucl, nihil::ucl::emitter::configuration,
-	     std::back_inserter(output));
+	emit(ucl, nihil::ucl::emitter::configuration, std::back_inserter(output));
 
 	REQUIRE(output == "bool = true;\n");
 }
@@ -182,12 +193,14 @@ TEST_CASE("ucl: boolean: format", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("bare boolean") {
+	SECTION("bare boolean")
+	{
 		auto str = std::format("{}", boolean(true));
 		REQUIRE(str == "true");
 	}
 
-	SECTION("parsed boolean") {
+	SECTION("parsed boolean")
+	{
 		auto obj = parse("bool = true;").value();
 		auto b = object_cast<boolean>(obj["bool"]).value();
 
@@ -195,7 +208,8 @@ TEST_CASE("ucl: boolean: format", "[ucl]")
 		REQUIRE(str == "true");
 	}
 
-	SECTION("with format string") {
+	SECTION("with format string")
+	{
 		auto str = std::format("{: >5}", boolean(true));
 		REQUIRE(str == " true");
 	}
@@ -205,14 +219,16 @@ TEST_CASE("ucl: boolean: print to ostream", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("bare boolean") {
+	SECTION("bare boolean")
+	{
 		auto strm = std::ostringstream();
 		strm << boolean(true);
 
 		REQUIRE(strm.str() == "true");
 	}
 
-	SECTION("parsed boolean") {
+	SECTION("parsed boolean")
+	{
 		auto obj = parse("bool = true;").value();
 		auto i = object_cast<boolean>(obj["bool"]).value();
 
@@ -222,3 +238,4 @@ TEST_CASE("ucl: boolean: print to ostream", "[ucl]")
 		REQUIRE(strm.str() == "true");
 	}
 }
+} // anonymous namespace
diff --git a/nihil.ucl/emit.cc b/nihil.ucl/emit.cc
deleted file mode 100644
index 480ddd8..0000000
--- a/nihil.ucl/emit.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <iostream>
-#include <iterator>
-
-module nihil.ucl;
-
-namespace nihil::ucl {
-
-auto operator<<(std::ostream &stream, object const &o)
--> std::ostream &
-{
-	emit(o, emitter::json, std::ostream_iterator<char>(stream));
-	return stream;
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/emit.ccm b/nihil.ucl/emit.ccm
index b88f8e7..64b8f4f 100644
--- a/nihil.ucl/emit.ccm
+++ b/nihil.ucl/emit.ccm
@@ -1,110 +1,83 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <array>
-#include <charconv>
-#include <cstdlib>
-#include <format>
-#include <iterator>
-#include <iosfwd>
-#include <span>
-#include <string>
-#include <utility>
-
 #include <ucl.h>
 
 export module nihil.ucl:emit;
 
+import nihil.std;
 import :object;
 
 namespace nihil::ucl {
 
-export enum struct emitter {
+export enum struct emitter : std::uint8_t {
 	configuration = UCL_EMIT_CONFIG,
 	compact_json = UCL_EMIT_JSON_COMPACT,
 	json = UCL_EMIT_JSON,
 	yaml = UCL_EMIT_YAML,
 };
 
-/*
- * Wrap ucl_emitter_functions for a particular output iterator type.
- *
- * We can't throw exceptions here since we're called from C code.  The emit
- * functions return an integer value, but it's not really clear what this is
- * for and the C API seems to mostly ignore it.  So, we just eat errors and
- * keep going.
- */
-template<std::output_iterator<char> Iterator>
-struct emit_wrapper {
-	emit_wrapper(Iterator iterator_)
-		: iterator(std::move(iterator_))
-	{}
-
-	static auto append_character(unsigned char c, std::size_t nchars,
-				     void *ud)
-		noexcept -> int
-	try {
-		auto *self = static_cast<emit_wrapper *>(ud);
-
-		while (nchars--)
-			*self->iterator++ = static_cast<char>(c);
+// Wrap ucl_emitter_functions for a particular output iterator type.
+//
+// We can't throw exceptions here since we're called from C code.  The emit
+// functions return an integer value, but it's not really clear what this is
+// for and the C API seems to mostly ignore it.  So, we just eat errors and
+// keep going.
+template <std::output_iterator<char> Iterator>
+struct emit_wrapper
+{
+	explicit emit_wrapper(Iterator iterator)
+		: m_iterator(std::move(iterator))
+	{
+	}
 
+	static auto
+	append_character(unsigned char const c, std::size_t nchars, void *const ud) noexcept -> int
+	try {
+		auto &self = check_magic(ud);
+		self.m_iterator =
+			std::ranges::fill_n(self.m_iterator, nchars, static_cast<char>(c));
 		return 0;
 	} catch (...) {
 		return 0;
 	}
 
-	static auto append_len(unsigned char const *str, std::size_t len,
-			       void *ud) 
-		noexcept -> int
+	static auto append_len(unsigned char const *const str, std::size_t const len,
+	                       void *const ud) noexcept -> int
 	try {
-		auto *self = static_cast<emit_wrapper *>(ud);
-
-		for (auto c : std::span(str, len))
-			*self->iterator++ = static_cast<char>(c);
-
+		auto &self = check_magic(ud);
+		self.m_iterator = std::ranges::copy(std::span(str, len), self.m_iterator).out;
 		return 0;
 	} catch (...) {
 		return 0;
 	}
 
-	static auto append_int(std::int64_t value, void *ud)
-		noexcept -> int
+	static auto append_int(std::int64_t const value, void *const ud) noexcept -> int
 	try {
-		auto constexpr bufsize =
-			std::numeric_limits<std::int64_t>::digits10;
-		auto buf = std::array<char, bufsize>();
+		auto &self = check_magic(ud);
 
-		auto *self = static_cast<emit_wrapper *>(ud);
-		auto result = std::to_chars(buf.data(), buf.data() + buf.size(),
-					    value, 10);
-
-		if (result.ec == std::errc())
-			for (auto c : std::span(buf.data(), result.ptr))
-				*self->iterator++ = c;
+		auto buf = std::array<char, std::numeric_limits<std::int64_t>::digits10>();
+		auto result = std::to_chars(begin(buf), end(buf), value, 10);
+		if (result.ec == std::errc()) {
+			auto chars = std::span(buf.data(), result.ptr);
+			self.m_iterator = std::ranges::copy(chars, self.m_iterator).out;
+		}
 
 		return 0;
 	} catch (...) {
 		return 0;
 	}
 
-	static auto append_double(double value, void *ud)
-		noexcept -> int
+	static auto append_double(double const value, void *const ud) noexcept -> int
 	try {
-		auto constexpr bufsize =
-			std::numeric_limits<double>::digits10;
-		auto buf = std::array<char, bufsize>();
-
-		auto *self = static_cast<emit_wrapper *>(ud);
-		auto result = std::to_chars(buf.data(), buf.data() + buf.size(),
-					    value);
+		auto &self = check_magic(ud);
 
-		if (result.ec == std::errc())
-			for (auto c : std::span(buf.data(), result.ptr))
-				*self->iterator++ = c;
+		auto buf = std::array<char, std::numeric_limits<double>::digits10>();
+		auto result = std::to_chars(begin(buf), end(buf), value);
+		if (result.ec == std::errc()) {
+			auto chars = std::span(buf.data(), result.ptr);
+			self.m_iterator = std::ranges::copy(chars, self.m_iterator).out;
+		}
 
 		return 0;
 	} catch (...) {
@@ -124,40 +97,61 @@ struct emit_wrapper {
 		return ret;
 	}
 
+	[[nodiscard]] auto iterator(this emit_wrapper &self) -> Iterator &
+	{
+		return self.m_iterator;
+	}
+
+	[[nodiscard]] auto iterator(this emit_wrapper const &self) -> Iterator const &
+	{
+		return self.m_iterator;
+	}
+
 private:
-	Iterator iterator{};
+	Iterator      m_iterator{};
+	std::uint64_t m_magic = wrapper_magic;
+
+	// Harden against memory errors.
+	static constexpr auto wrapper_magic = std::uint32_t{0x57524150};
+
+	static auto check_magic(void *p) -> emit_wrapper &
+	{
+		auto *ret = static_cast<emit_wrapper *>(p);
+		if (ret->m_magic != wrapper_magic)
+			throw std::runtime_error("Invalid emit_wrapper pointer");
+		return *ret;
+	}
 };
 
-export auto emit(object const &object, emitter format,
-		 std::output_iterator<char> auto &&it)
-	-> void
+export auto
+emit(object const &object, emitter const format, std::output_iterator<char> auto &&it) -> void
 {
 	auto ucl_format = static_cast<ucl_emitter>(format);
 	auto wrapper = emit_wrapper(it);
 	auto functions = wrapper.get_functions();
 
-	::ucl_object_emit_full(object.get_ucl_object(), ucl_format,
-			       &functions, nullptr);
+	::ucl_object_emit_full(object.get_ucl_object(), ucl_format, &functions, nullptr);
 }
 
-/*
- * Basic ostream printer for UCL; default to JSON since it's probably what
- * most people expect.
- */
-export auto operator<<(std::ostream &, object const &) -> std::ostream &;
+// Basic ostream printer for UCL; default to JSON since it's probably what
+// most people expect.  Note that most derived UCL types override this.
+export auto operator<<(std::ostream &stream, object const &o) -> std::ostream &
+{
+	emit(o, emitter::json, std::ostream_iterator<char>(stream));
+	return stream;
+}
 
 } // namespace nihil::ucl
 
-/*
- * Specialisation of std::formatter<> for object.
- */
-template<std::derived_from<nihil::ucl::object> T>
+// Specialisation of std::formatter<> for object.  Note that most derived
+// UCL types override this.
+template <std::derived_from<nihil::ucl::object> T>
 struct std::formatter<T, char>
 {
 	nihil::ucl::emitter emitter = nihil::ucl::emitter::json;
 
-	template<class ParseContext>
-	constexpr ParseContext::iterator parse(ParseContext& ctx)
+	template <class ParseContext>
+	constexpr auto parse(ParseContext &ctx) -> ParseContext::iterator
 	{
 		auto it = ctx.begin();
 		auto end = ctx.end();
@@ -179,8 +173,7 @@ struct std::formatter<T, char>
 			case '}':
 				return it;
 			default:
-				throw std::format_error("Invalid format string "
-							"for UCL object");
+				throw std::format_error("Invalid format string for UCL object");
 			}
 
 			++it;
@@ -189,9 +182,8 @@ struct std::formatter<T, char>
 		return it;
 	}
 
-	template<class FmtContext>
-	FmtContext::iterator format(nihil::ucl::object const &o,
-				    FmtContext& ctx) const
+	template <class FmtContext>
+	auto format(nihil::ucl::object const &o, FmtContext &ctx) const -> FmtContext::iterator
 	{
 		// We can't use emit() here since the context iterator is not
 		// an std::output_iterator.
@@ -202,8 +194,7 @@ struct std::formatter<T, char>
 		auto wrapper = nihil::ucl::emit_wrapper(out);
 		auto functions = wrapper.get_functions();
 
-		::ucl_object_emit_full(o.get_ucl_object(), ucl_format,
-				       &functions, nullptr);
-		return out;
+		::ucl_object_emit_full(o.get_ucl_object(), ucl_format, &functions, nullptr);
+		return wrapper.iterator();
 	}
 };
diff --git a/nihil.ucl/tests/emit.cc b/nihil.ucl/emit.test.cc
index a7dcd71..51c4e0e 100644
--- a/nihil.ucl/tests/emit.cc
+++ b/nihil.ucl/emit.test.cc
@@ -1,14 +1,11 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <format>
-#include <sstream>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.ucl;
 
+namespace {
 TEST_CASE("ucl: emit to std::ostream", "[ucl]")
 {
 	using namespace std::literals;
@@ -91,3 +88,5 @@ TEST_CASE("ucl: emit YAML with std::format", "[ucl]")
 "    666\n"
 "]");
 }
+
+} // anonymous namespace
diff --git a/nihil.ucl/errc.cc b/nihil.ucl/errc.cc
deleted file mode 100644
index 0b65b86..0000000
--- a/nihil.ucl/errc.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <string>
-#include <system_error>
-
-module nihil.ucl;
-
-namespace nihil::ucl {
-
-struct ucl_error_category final : std::error_category {
-	auto name() const noexcept -> char const * override;
-	auto message(int err) const -> std::string override;
-};
-
-auto ucl_category() noexcept -> std::error_category &
-{
-	static auto category = ucl_error_category();
-	return category;
-}
-
-auto make_error_condition(errc ec) -> std::error_condition
-{
-	return {static_cast<int>(ec), ucl_category()};
-}
-
-auto ucl_error_category::name() const noexcept -> char const *
-{
-	return "nihil.ucl";
-}
-
-auto ucl_error_category::message(int err) const -> std::string
-{
-	switch (static_cast<errc>(err)) {
-	case errc::no_error:
-		return "No error";
-	case errc::failed_to_create_object:
-		return "Failed to create UCL object";
-	case errc::type_mismatch:
-		return "UCL type does not match expected type";
-	default:
-		return "Undefined error";
-	}
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/errc.ccm b/nihil.ucl/errc.ccm
deleted file mode 100644
index 8f0444d..0000000
--- a/nihil.ucl/errc.ccm
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <string>
-#include <system_error>
-
-export module nihil.ucl:errc;
-
-namespace nihil::ucl {
-
-export enum struct errc {
-	no_error = 0,
-
-	// ucl_object_new() or similar failed, e.g. out of memory
-	failed_to_create_object,
-	// Trying to create an object from a UCL object of the wrong type
-	type_mismatch,
-};
-
-export auto ucl_category() noexcept -> std::error_category &;
-export auto make_error_condition(errc ec) -> std::error_condition;
-
-} // namespace nihil::ucl
-
-namespace std {
-
-export template<>
-struct is_error_condition_enum<nihil::ucl::errc> : true_type {};
-
-} // namespace std
diff --git a/nihil.ucl/integer.cc b/nihil.ucl/integer.cc
deleted file mode 100644
index 825d8f6..0000000
--- a/nihil.ucl/integer.cc
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <compare>
-#include <cstdlib>
-#include <expected>
-#include <system_error>
-
-#include <ucl.h>
-
-module nihil.ucl;
-
-import nihil.error;
-
-namespace nihil::ucl {
-
-integer::integer()
-	: integer(0)
-{
-}
-
-integer::integer(contained_type value)
-	: integer(noref, [&] {
-		auto *uobj = ::ucl_object_fromint(value);
-		if (uobj == nullptr)
-			throw std::system_error(
-				std::make_error_code(std::errc(errno)));
-		return uobj;
-	}())
-{
-}
-
-integer::integer(ref_t, ::ucl_object_t const *uobj)
-	: object(nihil::ucl::ref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != integer::ucl_type)
-			throw type_mismatch(integer::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-integer::integer(noref_t, ::ucl_object_t *uobj)
-	: object(nihil::ucl::noref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != integer::ucl_type)
-			throw type_mismatch(integer::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-auto make_integer(integer::contained_type value)
-	-> std::expected<integer, error>
-{
-	auto *uobj = ::ucl_object_fromint(value);
-	if (uobj == nullptr)
-		return std::unexpected(error(
-			errc::failed_to_create_object,
-			error(std::errc(errno))));
-
-	return integer(noref, uobj);
-}
-
-auto integer::value(this integer const &self) -> contained_type
-{
-	auto v = contained_type{};
-	auto const *uobj = self.get_ucl_object();
-
-	if (::ucl_object_toint_safe(uobj, &v))
-		return v;
-
-	std::abort();
-}
-
-auto operator== (integer const &a, integer const &b) -> bool
-{
-	return a.value() == b.value();
-}
-
-auto operator<=> (integer const &a, integer const &b) -> std::strong_ordering
-{
-	return a.value() <=> b.value();
-}
-
-auto operator== (integer const &a, integer::contained_type b) -> bool
-{
-	return a.value() == b;
-}
-
-auto operator<=> (integer const &a, integer::contained_type b)
-	-> std::strong_ordering
-{
-	return a.value() <=> b;
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/integer.ccm b/nihil.ucl/integer.ccm
index e35a471..eb7fa6b 100644
--- a/nihil.ucl/integer.ccm
+++ b/nihil.ucl/integer.ccm
@@ -1,114 +1,139 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <compare>
-#include <cstdint>
-#include <cstdlib>
-#include <expected>
-#include <format>
-#include <utility>
-
 #include <ucl.h>
 
 export module nihil.ucl:integer;
 
+import nihil.std;
+import nihil.core;
+import nihil.error;
 import :object;
 import :type;
 
 namespace nihil::ucl {
 
-export struct integer final : object {
+export struct integer final : object
+{
 	using contained_type = std::int64_t;
-	inline static constexpr object_type ucl_type = object_type::integer;
-
-	/*
-	 * Create an integer holding the value 0.  Throws std::system_error
-	 * on failure.
-	 */
-	integer();
-
-	/*
-	 * Create an integer holding a specific value.  Throws std::system_error
-	 * on failure.
-	 */
-	explicit integer(contained_type value);
-
-	/*
-	 * Create a new integer from a UCL object.  Throws type_mismatch
-	 * on failure.
-	 */
-	integer(ref_t, ::ucl_object_t const *uobj);
-	integer(noref_t, ::ucl_object_t *uobj);
+	static constexpr object_type ucl_type = object_type::integer;
+
+	// Create an integer holding the value 0.  Throws std::system_error
+	// on failure.
+	integer()
+		: integer(0)
+	{
+	}
+
+	// Create an integer holding a specific value.  Throws std::system_error
+	// on failure.
+	explicit integer(contained_type value)
+		: integer(noref, [&] {
+			auto *uobj = ::ucl_object_fromint(value);
+			if (uobj == nullptr)
+				throw std::system_error(std::make_error_code(sys_error()));
+			return uobj;
+		}())
+	{
+	}
+
+	// Create a new integer from a UCL object.  Throws type_mismatch
+	// on failure.
+	integer(ref_t, ::ucl_object_t const *uobj)
+		: object(nihil::ucl::ref, ensure_ucl_type(uobj, integer::ucl_type))
+	{
+	}
+
+	integer(noref_t, ::ucl_object_t *uobj)
+		: object(nihil::ucl::noref, ensure_ucl_type(uobj, integer::ucl_type))
+	{
+	}
 
 	// Return the value of this object.
-	[[nodiscard]] auto value(this integer const &self) -> contained_type;
-};
+	[[nodiscard]] auto value(this integer const &self) -> contained_type
+	{
+		auto        v = contained_type{};
+		auto const *uobj = self.get_ucl_object();
 
-/*
- * Integer constructors.  These return an error instead of throwing.
- */
+		if (::ucl_object_toint_safe(uobj, &v))
+			return v;
 
-export [[nodiscard]] auto
-make_integer(integer::contained_type = 0) -> std::expected<integer, error>;
+		throw std::runtime_error("ucl_object_toint_safe failed");
+	}
 
-/*
- * Comparison operators.
- */
+private:
+	//
+	// Comparison operators.
+	//
 
-export [[nodiscard]] auto operator== (integer const &a,
-				      integer const &b) -> bool;
+	[[nodiscard]] friend auto operator==(integer const &a, integer const &b) -> bool
+	{
+		return a.value() == b.value();
+	}
 
-export [[nodiscard]] auto operator== (integer const &a,
-				      integer::contained_type b) -> bool;
+	[[nodiscard]] friend auto operator==(integer const &a, integer::contained_type b) -> bool
+	{
+		return a.value() == b;
+	}
 
-export [[nodiscard]] auto operator<=> (integer const &a,
-				       integer const &b)
-	-> std::strong_ordering;
+	[[nodiscard]] friend auto
+	operator<=>(integer const &a, integer const &b) -> std::strong_ordering
+	{
+		return a.value() <=> b.value();
+	}
 
-export [[nodiscard]] auto operator<=> (integer const &a,
-				       integer::contained_type b)
-	-> std::strong_ordering;
+	[[nodiscard]] friend auto
+	operator<=>(integer const &a, integer::contained_type b) -> std::strong_ordering
+	{
+		return a.value() <=> b;
+	}
+};
+
+// Integer constructors.  This returns an error instead of throwing.
+export [[nodiscard]] auto
+make_integer(integer::contained_type value = 0) -> std::expected<integer, error>
+{
+	auto *uobj = ::ucl_object_fromint(value);
+	if (uobj == nullptr)
+		return error(errc::failed_to_create_object, error(sys_error()));
+
+	return integer(noref, uobj);
+}
 
-/*
- * Literal operator.
- */
+// Literal operator for integers.
 inline namespace literals {
-export constexpr auto operator""_ucl (unsigned long long i) -> integer
+export constexpr auto operator""_ucl(unsigned long long i) -> integer
 {
 	if (std::cmp_greater(i, std::numeric_limits<std::int64_t>::max()))
 		throw std::out_of_range("literal out of range");
 
 	return integer(static_cast<std::int64_t>(i));
 }
-} // namespace nihil::ucl::literals
+} // namespace literals
 
 } // namespace nihil::ucl
 
-namespace nihil { inline namespace literals {
-	export using namespace ::nihil::ucl::literals;
-}} // namespace nihil::literals
+namespace nihil {
+inline namespace literals {
+export using namespace ::nihil::ucl::literals;
+} // namespace literals
+} // namespace nihil
 
-/*
- * std::formatter for an integer.  This provides the same format operations
- * as std::formatter<std::int64_t>.
- */
-export template<>
+// std::formatter for an integer.  This provides the same format operations
+// as std::formatter<std::int64_t>.
+export template <>
 struct std::formatter<nihil::ucl::integer, char>
 {
 	std::formatter<std::int64_t> base_formatter;
 
-	template<class ParseContext>
-	constexpr ParseContext::iterator parse(ParseContext& ctx)
+	template <class ParseContext>
+	constexpr auto parse(ParseContext &ctx) -> ParseContext::iterator
 	{
 		return base_formatter.parse(ctx);
 	}
 
-	template<class FmtContext>
-	FmtContext::iterator format(nihil::ucl::integer const &o,
-				    FmtContext& ctx) const
+	template <class FmtContext>
+	auto format(nihil::ucl::integer const &o, FmtContext &ctx) const -> FmtContext::iterator
 	{
 		return base_formatter.format(o.value(), ctx);
 	}
diff --git a/nihil.ucl/tests/integer.cc b/nihil.ucl/integer.test.cc
index 6584764..68567e9 100644
--- a/nihil.ucl/tests/integer.cc
+++ b/nihil.ucl/integer.test.cc
@@ -1,16 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <concepts>
-#include <cstdint>
-#include <string>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 #include <ucl.h>
 
+import nihil.std;
 import nihil.ucl;
 
+namespace {
 TEST_CASE("ucl: integer: invariants", "[ucl]")
 {
 	using namespace nihil::ucl;
@@ -67,7 +63,7 @@ TEST_CASE("ucl: integer: construct from UCL object", "[ucl]")
 	using namespace nihil::ucl;
 
 	SECTION("ref, correct type") {
-		auto uobj = ::ucl_object_fromint(42);
+		auto *uobj = ::ucl_object_fromint(42);
 
 		auto i = integer(ref, uobj);
 		REQUIRE(i == 42);
@@ -76,14 +72,14 @@ TEST_CASE("ucl: integer: construct from UCL object", "[ucl]")
 	}
 
 	SECTION("noref, correct type") {
-		auto uobj = ::ucl_object_fromint(42);
+		auto *uobj = ::ucl_object_fromint(42);
 
 		auto i = integer(noref, uobj);
 		REQUIRE(i == 42);
 	}
 
 	SECTION("ref, wrong type") {
-		auto uobj = ::ucl_object_frombool(true);
+		auto *uobj = ::ucl_object_frombool(true);
 
 		REQUIRE_THROWS_AS(integer(ref, uobj), type_mismatch);
 
@@ -91,7 +87,7 @@ TEST_CASE("ucl: integer: construct from UCL object", "[ucl]")
 	}
 
 	SECTION("noref, wrong type") {
-		auto uobj = ::ucl_object_frombool(true);
+		auto *uobj = ::ucl_object_frombool(true);
 
 		REQUIRE_THROWS_AS(integer(noref, uobj), type_mismatch);
 
@@ -147,7 +143,7 @@ TEST_CASE("ucl: integer: key()", "[ucl]")
 
 	SECTION("bare integer, no key") {
 		auto i = 42_ucl;
-		REQUIRE(i.key() == "");
+		REQUIRE(i.key().empty() == true);
 	}
 }
 
@@ -245,3 +241,4 @@ TEST_CASE("ucl: integer: print to ostream", "[ucl]")
 		REQUIRE(strm.str() == "42");
 	}
 }
+} // anonymous namespace
diff --git a/nihil.ucl/map.ccm b/nihil.ucl/map.ccm
index fa77601..73ef583 100644
--- a/nihil.ucl/map.ccm
+++ b/nihil.ucl/map.ccm
@@ -1,47 +1,41 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <format>
-#include <memory>
-#include <optional>
-#include <string>
-#include <system_error>
-
 #include <ucl.h>
 
 export module nihil.ucl:map;
 
+import nihil.std;
 import :object;
 
 namespace nihil::ucl {
 
 // Exception thrown when map::operator[] does not find the key.
-export struct key_not_found : error {
-	key_not_found(std::string_view key)
+export struct key_not_found : error
+{
+	explicit key_not_found(std::string_view key)
 		: error(std::format("key '{}' not found in map", key))
 		, m_key(key)
-	{}
+	{
+	}
 
 	auto key(this key_not_found const &self) -> std::string_view
 	{
 		return self.m_key;
 	}
-	
+
 private:
 	std::string m_key;
 };
 
-export template<datatype T>
+export template <datatype T>
 struct map;
 
-template<datatype T>
-struct map_iterator {
+// The map iterator.  UCL doesn't provide a way to copy an iterator, so this is an
+// input iterator: it can only go forwards.
+template <datatype T>
+struct map_iterator
+{
 	using difference_type = std::ptrdiff_t;
 	using value_type = std::pair<std::string_view, T>;
 	using reference = value_type &;
@@ -49,242 +43,219 @@ struct map_iterator {
 	using pointer = value_type *;
 	using const_pointer = value_type const *;
 
-	struct sentinel{};
+	struct sentinel
+	{
+	};
 
-	[[nodiscard]] auto operator==(this map_iterator const &self, sentinel)
-		-> bool
+	[[nodiscard]] auto operator==(this map_iterator const &self, sentinel) -> bool
 	{
-		return (self.m_state->cur == nullptr);
+		return self.m_state->current_object() == nullptr;
 	}
 
 	auto operator++(this map_iterator &self) -> map_iterator &
 	{
-		self.m_state->next();
+		self.m_state->advance();
 		return self;
 	}
 
 	auto operator++(this map_iterator &self, int) -> map_iterator &
 	{
-		self.m_state->next();
+		self.m_state->advance();
 		return self;
 	}
 
-	[[nodiscard]] auto operator*(this map_iterator const &self)
-		-> value_type
+	[[nodiscard]] auto operator*(this map_iterator const &self) -> value_type
 	{
-		auto obj = T(ref, self.m_state->cur);
+		auto *cur = self.m_state->current_object();
+		if (cur == nullptr)
+			throw std::logic_error("map_iterator::operator* called on end()");
+
+		auto obj = T(ref, cur);
 		return {obj.key(), std::move(obj)};
 	}
 
 private:
 	friend struct map<T>;
 
-	map_iterator(::ucl_object_t const *obj)
+	explicit map_iterator(::ucl_object_t const *obj)
 		: m_state(std::make_shared<state>(obj))
 	{
 		++(*this);
 	}
 
-	struct state {
-		state(::ucl_object_t const *obj)
+	struct state
+	{
+		explicit state(::ucl_object_t const *obj)
+			: m_ucl_iterator([obj] {
+				if (auto *iter = ::ucl_object_iterate_new(obj); iter != nullptr)
+					return iter;
+				throw std::system_error(make_error_code(sys_error()));
+			}())
 		{
-			iter = ::ucl_object_iterate_new(obj);
-			if (iter == nullptr)
-				throw std::system_error(make_error_code(
-					std::errc(errno)));
 		}
 
 		state(state const &) = delete;
-		auto operator=(this state &, state const &) -> state& = delete;
+		auto operator=(state const &) -> state & = delete;
+
+		state(state &&) = delete;
+		auto operator=(state &&) -> state & = delete;
 
 		~state()
 		{
-			if (iter != nullptr)
-				::ucl_object_iterate_free(iter);
+			if (m_ucl_iterator != nullptr)
+				::ucl_object_iterate_free(m_ucl_iterator);
+		}
+
+		auto advance(this state &self) -> void
+		{
+			self.m_current_object = ::ucl_object_iterate_safe(self.m_ucl_iterator, true);
 		}
 
-		auto next() -> void
+		auto current_object(this state const &self) -> ::ucl_object_t const *
 		{
-			cur = ::ucl_object_iterate_safe(iter, true);
+			return self.m_current_object;
 		}
 
-		ucl_object_iter_t iter = nullptr;
-		ucl_object_t const *cur = nullptr;
+	private:
+		ucl_object_iter_t   m_ucl_iterator = nullptr;
+		ucl_object_t const *m_current_object = nullptr;
 	};
 
 	std::shared_ptr<state> m_state;
 };
 
-export template<datatype T = object>
-struct map final : object {
-	inline static constexpr object_type ucl_type = object_type::object;
+export template <datatype T = object>
+struct map final : object
+{
+	static constexpr auto ucl_type = object_type::object;
 
 	using value_type = std::pair<std::string_view, T>;
 	using size_type = std::size_t;
 	using difference_type = std::ptrdiff_t;
 	using iterator = map_iterator<T>;
+	using sentinel = typename iterator::sentinel;
 
-	/*
-	 * Create an empty map.  Throws std::system_error on failure.
-	 */
-	map()	: object(noref, [] {
+	~map() override = default;
+
+	// Create an empty map.  Throws std::system_error on failure.
+	map()
+		: object(noref, [] {
 			auto *uobj = ::ucl_object_typed_new(UCL_OBJECT);
 			if (uobj == nullptr)
-				throw std::system_error(
-					std::make_error_code(std::errc(errno)));
+				throw std::system_error(std::make_error_code(sys_error()));
 			return uobj;
 		}())
 	{
 	}
 
-	/*
-	 * Create a map from a UCL object.  Throws type_mismatch on failure.
-	 *
-	 * Unlike object_cast<>, this does not check the type of the contained
-	 * elements, which means object access can throw type_mismatch.
-	 */
-	map(ref_t, ::ucl_object_t const *uobj)
-		: object(nihil::ucl::ref, [&] {
-			auto actual_type = static_cast<object_type>(
-						::ucl_object_type(uobj));
-			if (actual_type != map::ucl_type)
-				throw type_mismatch(map::ucl_type,
-						    actual_type);
-			return uobj;
-		}())
+	// Create a map from a UCL object.  Throws type_mismatch on failure.
+	//
+	// Unlike object_cast<>, this does not check the type of the contained
+	// elements, which means object access can throw type_mismatch.
+	map(ref_t, ::ucl_object_t const * const uobj)
+		: object(nihil::ucl::ref, ensure_ucl_type(uobj, map::ucl_type))
 	{
-		if (type() != ucl_type)
-			throw type_mismatch(ucl_type, type());
 	}
 
-	map(noref_t, ::ucl_object_t *uobj)
-		: object(nihil::ucl::noref, [&] {
-			auto actual_type = static_cast<object_type>(
-						::ucl_object_type(uobj));
-			if (actual_type != map::ucl_type)
-				throw type_mismatch(map::ucl_type,
-						    actual_type);
-			return uobj;
-		}())
+	map(noref_t, ::ucl_object_t * const uobj)
+		: object(nihil::ucl::noref, ensure_ucl_type(uobj, map::ucl_type))
 	{
 	}
 
-	/*
-	 * Create a map from an iterator pair.
-	 */
-	template<std::input_iterator Iterator>
-	requires(std::convertible_to<std::iter_value_t<Iterator>, value_type>)
-	map(Iterator first, Iterator last)
-		 : map()
+	// Create a map from a range of value types.
+	template <std::ranges::range Range>
+	requires(std::convertible_to<std::ranges::range_value_t<Range>, value_type>)
+	explicit map(Range const &range)
+		: map()
 	{
 		// This is exception safe, because if we throw here the
 		// base class destructor will free the map.
-		while (first != last) {
-			insert(*first);
-			++first;
-		}
+		for (auto &&v: range)
+			insert(v);
 	}
 
-	/*
-	 * Create a map from a range.
-	 */
-	template<std::ranges::range Range>
-	requires(std::convertible_to<std::ranges::range_value_t<Range>,
-		 		     value_type>)
-	map(std::from_range_t, Range &&range)
-		 : map(std::ranges::begin(range),
-		       std::ranges::end(range))
+	// Create a map from an iterator pair.
+	template <std::input_iterator Iterator>
+	requires(std::convertible_to<std::iter_value_t<Iterator>, value_type>)
+	map(Iterator first, Iterator last)
+		: map(std::ranges::subrange(first, last))
 	{
 	}
 
-	/*
-	 * Create a map from an initializer_list.
-	 */
+	// Create a map from an initializer_list.
 	map(std::initializer_list<value_type> const &list)
-		 : map(std::ranges::begin(list), std::ranges::end(list))
+		: map(std::ranges::subrange(std::ranges::begin(list), std::ranges::end(list)))
 	{
 	}
 
-	/*
-	 * Map iterator access.
-	 */
+	// Copyable.  Note that this copies the entire UCL object.
+	map(map const &) = default;
+	auto operator=(map const &) -> map & = default;
+
+	// Movable.
+	map(map &&) = default;
+	auto operator=(map &&other) -> map & = default;
+
+	//
+	// Map iterator access.
+	//
 
 	[[nodiscard]] auto begin(this map const &self) -> iterator
 	{
-		return {self.get_ucl_object()};
+		return iterator(self.get_ucl_object());
 	}
 
-	[[nodiscard]] auto end(this map const &) -> iterator::sentinel
+	[[nodiscard]] auto end(this map const &) -> sentinel
 	{
 		return {};
 	}
 
-	/*
-	 * Reserve space for future insertions.
-	 */
-	auto reserve(this map &self, size_type nelems) -> void
+	// Reserve space for future insertions.
+	auto reserve(this map &self, size_type const nelems) -> void
 	{
 		::ucl_object_reserve(self.get_ucl_object(), nelems);
 	}
 
-	/*
-	 * Add an element to the map.
-	 */
+	// Add an element to the map.
 	auto insert(this map &self, value_type const &v) -> void
 	{
 		auto uobj = ::ucl_object_ref(v.second.get_ucl_object());
 
-		::ucl_object_insert_key(self.get_ucl_object(), uobj,
-					v.first.data(), v.first.size(), true);
+		::ucl_object_insert_key(self.get_ucl_object(), uobj, v.first.data(), v.first.size(),
+		                        true);
 	}
 
-	/*
-	 * Access a map element by key.
-	 */
-	[[nodiscard]] auto find(this map const &self, std::string_view key)
-		-> std::optional<T>
+	// Access a map element by key.
+	[[nodiscard]] auto find(this map const &self, std::string_view const key) -> std::optional<T>
 	{
-		auto const *obj = ::ucl_object_lookup_len(
-					self.get_ucl_object(),
-					key.data(), key.size());
+		auto const *obj =
+			::ucl_object_lookup_len(self.get_ucl_object(), key.data(), key.size());
 		if (obj == nullptr)
 			return {};
 
 		return {T(nihil::ucl::ref, obj)};
 	}
 
-	/*
-	 * Remove an object from the map.
-	 */
-	auto remove(this map &self, std::string_view key) -> bool
+	// Remove an object from the map.
+	auto remove(this map &self, std::string_view const key) -> bool
 	{
-		return ::ucl_object_delete_keyl(self.get_ucl_object(),
-						key.data(), key.size());
+		return ::ucl_object_delete_keyl(self.get_ucl_object(), key.data(), key.size());
 	}
 
-	/*
-	 * Remove an object from the map and return it.
-	 */
-	auto pop(this map &self, std::string_view key)
-		-> std::optional<T>
+	// Remove an object from the map and return it.  If the map is empty, returns nullopt.
+	auto pop(this map &self, std::string_view const key) -> std::optional<T>
 	{
-		auto *uobj = ::ucl_object_pop_keyl(self.get_ucl_object(),
-						   key.data(), key.size());
+		auto *uobj = ::ucl_object_pop_keyl(self.get_ucl_object(), key.data(), key.size());
 		if (uobj)
 			return T(noref, uobj);
 		return {};
 	}
 
-	/*
-	 * Equivalent to find(), except it throws key_not_found if the key
-	 * doesn't exist in the map.
-	 */
-	[[nodiscard]] auto operator[] (this map const &self,
-				       std::string_view key)
-		-> T
+	// Equivalent to find(), except it throws key_not_found if the key
+	// doesn't exist in the map.
+	[[nodiscard]] auto operator[](this map const &self, std::string_view const key) -> T
 	{
-		auto obj = self.find(key);
-		if (obj)
+		if (auto obj = self.find(key); obj	)
 			return *obj;
 		throw key_not_found(key);
 	}
diff --git a/nihil.ucl/tests/map.cc b/nihil.ucl/map.test.cc
index 7240cb3..6d31af2 100644
--- a/nihil.ucl/tests/map.cc
+++ b/nihil.ucl/map.test.cc
@@ -1,16 +1,14 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <concepts>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 #include <ucl.h>
 
+import nihil.std;
 import nihil.ucl;
 
 //NOLINTBEGIN(bugprone-unchecked-optional-access)
 
+namespace {
 TEST_CASE("ucl: map: invariants", "[ucl]")
 {
 	using namespace nihil::ucl;
@@ -43,9 +41,9 @@ TEST_CASE("ucl: map: construct from initializer_list", "[ucl]")
 	using namespace std::literals;
 
 	auto map = nihil::ucl::map<integer>{
-		{"1"sv, integer(1)},
-		{"42"sv, integer(42)},
-	};
+			{"1"sv, integer(1)},
+			{"42"sv, integer(42)},
+		};
 
 	REQUIRE(str(map.type()) == "object");
 	REQUIRE(map["1"] == 1);
@@ -58,11 +56,11 @@ TEST_CASE("ucl: map: construct from range", "[ucl]")
 	using namespace std::literals;
 
 	auto vec = std::vector<std::pair<std::string_view, integer>>{
-		{"1"sv, integer(1)},
-		{"42"sv, integer(42)},
-	};
+			{"1"sv, integer(1)},
+			{"42"sv, integer(42)},
+		};
 
-	auto map = nihil::ucl::map<integer>(std::from_range, vec);
+	auto map = nihil::ucl::map<integer>(vec);
 
 	REQUIRE(str(map.type()) == "object");
 	REQUIRE(map["1"] == 1);
@@ -75,9 +73,9 @@ TEST_CASE("ucl: map: construct from iterator pair", "[ucl]")
 	using namespace std::literals;
 
 	auto vec = std::vector<std::pair<std::string_view, integer>>{
-		{"1"sv, integer(1)},
-		{"42"sv, integer(42)},
-	};
+			{"1"sv, integer(1)},
+			{"42"sv, integer(42)},
+		};
 
 	auto map = nihil::ucl::map<integer>(std::ranges::begin(vec),
 					    std::ranges::end(vec));
@@ -107,9 +105,9 @@ TEST_CASE("ucl: map: find", "[ucl]")
 	using namespace std::literals;
 
 	auto map = nihil::ucl::map<integer>{
-		{"1"sv, integer(1)},
-		{"42"sv, integer(42)},
-	};
+			{"1"sv, integer(1)},
+			{"42"sv, integer(42)},
+		};
 
 	auto obj = map.find("42");
 	REQUIRE(obj.value() == 42);
@@ -124,11 +122,11 @@ TEST_CASE("ucl: map: iterate", "[ucl]")
 	using namespace std::literals;
 
 	auto map = nihil::ucl::map<integer>{
-		{"1"sv, integer(1)},
-		{"42"sv, integer(42)},
-	};
+			{"1"sv, integer(1)},
+			{"42"sv, integer(42)},
+		};
 
-	auto i = 0u;
+	auto i = 0U;
 
 	for (auto [key, value] : map) {
 		if (key == "1")
@@ -155,9 +153,9 @@ TEST_CASE("ucl: map: remove", "[uc]")
 	using namespace nihil::ucl;
 
 	auto map = nihil::ucl::map<integer>{
-		{"1"sv, integer(1)},
-		{"42"sv, integer(42)},
-	};
+			{"1"sv, integer(1)},
+			{"42"sv, integer(42)},
+		};
 
 	REQUIRE(map.find("42") != std::nullopt);
 	REQUIRE(map.remove("42") == true);
@@ -173,9 +171,9 @@ TEST_CASE("ucl: map: pop", "[uc]")
 	using namespace nihil::ucl;
 
 	auto map = nihil::ucl::map<integer>{
-		{"1"sv, integer(1)},
-		{"42"sv, integer(42)},
-	};
+			{"1"sv, integer(1)},
+			{"42"sv, integer(42)},
+		};
 
 	REQUIRE(map.find("42") != std::nullopt);
 
@@ -189,4 +187,6 @@ TEST_CASE("ucl: map: pop", "[uc]")
 	REQUIRE(!obj);
 }
 
+} // anonymous namespace
+
 //NOLINTEND(bugprone-unchecked-optional-access)
diff --git a/nihil.ucl/nihil.ucl.ccm b/nihil.ucl/nihil.ucl.ccm
index b16eb3d..daa751b 100644
--- a/nihil.ucl/nihil.ucl.ccm
+++ b/nihil.ucl/nihil.ucl.ccm
@@ -1,13 +1,7 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
+// This source code is released into the public domain.
 export module nihil.ucl;
 
 export import :emit;
-export import :errc;
 export import :object;
 export import :object_cast;
 export import :parser;
diff --git a/nihil.ucl/object.cc b/nihil.ucl/object.cc
deleted file mode 100644
index 53fc4c7..0000000
--- a/nihil.ucl/object.cc
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <cstdlib>
-#include <string>
-#include <utility>
-
-#include <ucl.h>
-
-module nihil.ucl;
-
-namespace nihil::ucl {
-
-object::object(ref_t, ::ucl_object_t const *object)
-	: m_object(::ucl_object_ref(object))
-{
-}
-
-object::object(noref_t, ::ucl_object_t *object)
-	: m_object(object)
-{
-}
-
-object::~object() {
-	if (m_object != nullptr)
-		::ucl_object_unref(m_object);
-}
-
-object::object(object &&other) noexcept
-	: m_object(std::exchange(other.m_object, nullptr))
-{}
-
-object::object(object const &other)
-	: m_object(nullptr)
-{
-	m_object = ::ucl_object_copy(other.get_ucl_object());
-	if (m_object == nullptr)
-		throw std::runtime_error("failed to copy UCL object");
-}
-
-auto object::operator=(this object &self, object &&other) noexcept
-	-> object &
-{
-	if (&self != &other)
-		self.m_object = std::exchange(other.m_object, nullptr);
-	return self;
-}
-
-auto object::operator=(this object &self, object const &other) -> object &
-{
-	return self = object(other);
-}
-
-auto object::ref(this object const &self) -> object
-{
-	return object(nihil::ucl::ref, self.get_ucl_object());
-}
-
-auto object::type(this object const &self) -> object_type
-{
-	auto utype = ::ucl_object_type(self.get_ucl_object());
-	return static_cast<object_type>(utype);
-}
-
-auto object::get_ucl_object(this object &self) -> ::ucl_object_t *
-{
-	if (self.m_object == nullptr)
-		throw std::logic_error("attempt to access empty UCL object");
-	return self.m_object;
-}
-
-auto object::get_ucl_object(this object const &self) -> ::ucl_object_t const *
-{
-	if (self.m_object == nullptr)
-		throw std::logic_error("attempt to access empty UCL object");
-	return self.m_object;
-}
-
-// Return the key of this object.
-auto object::key(this object const &self) -> std::string_view
-{
-	auto dlen = std::size_t{};
-	auto const *dptr = ::ucl_object_keyl(self.get_ucl_object(),
-					     &dlen);
-	return {dptr, dlen};
-}
-
-auto swap(object &a, object &b) -> void
-{
-	std::swap(a.m_object, b.m_object);
-}
-
-auto operator<=>(object const &lhs, object const &rhs) -> std::strong_ordering
-{
-	auto cmp = ::ucl_object_compare(lhs.get_ucl_object(),
-					rhs.get_ucl_object());
-
-	if (cmp < 0)
-		return std::strong_ordering::less;
-	else if (cmp > 0)
-		return std::strong_ordering::greater;
-	else
-		return std::strong_ordering::equal;
-}
-
-auto operator==(object const &lhs, object const &rhs) -> bool
-{
-	return (lhs <=> rhs) == std::strong_ordering::equal;
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/object.ccm b/nihil.ucl/object.ccm
index 9a7eaf7..93dc4db 100644
--- a/nihil.ucl/object.ccm
+++ b/nihil.ucl/object.ccm
@@ -1,88 +1,172 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-/*
- * A UCL object.  The object is immutable and internally refcounted, so it
- * may be copied as needed.
- *
- */
-
-#include <compare>
-#include <cstddef>
-#include <string>
+// A UCL object.  The object is immutable and internally refcounted, so it
+// may be copied as needed.
 
 #include <ucl.h>
 
 export module nihil.ucl:object;
 
+import nihil.std;
 import :type;
 
 namespace nihil::ucl {
 
-/***********************************************************************
- * The basic object type.
- */
+//***********************************************************************
+// The basic object type.
 
 // Ref the UCL object when creating an object.
-export inline constexpr struct ref_t {} ref;
+export inline constexpr struct ref_t
+{
+} ref;
+
 // Don't ref the UCL object.
-export inline constexpr struct noref_t {} noref;
+export inline constexpr struct noref_t
+{
+} noref;
 
-export struct object {
-	inline static constexpr object_type ucl_type = object_type::object;
+export struct object
+{
+	static constexpr object_type ucl_type = object_type::object;
 
 	// Create an object from an existing ucl_object_t.  The first argument
 	// determines whether we ref the object or not.
 
-	object(ref_t, ::ucl_object_t const *object);
-	object(noref_t, ::ucl_object_t *object);
+	object(ref_t, ::ucl_object_t const *object)
+		: m_object(::ucl_object_ref(object))
+	{
+	}
+
+	object(noref_t, ::ucl_object_t *object)
+		: m_object(object)
+	{
+	}
 
 	// Free our object on destruction.
-	virtual ~object();
+	virtual ~object()
+	{
+		if (m_object != nullptr)
+			::ucl_object_unref(m_object);
+	}
 
 	// Movable.
-	object(object &&other) noexcept;
-	auto operator=(this object &self, object &&other) noexcept -> object&;
-
-	// Copyable.
-	// Note that this copies the entire UCL object.
-	object(object const &other);
-	auto operator=(this object &self, object const &other) -> object &;
+	object(object &&other) noexcept
+		: m_object(std::exchange(other.m_object, nullptr))
+	{
+	}
+
+	auto operator=(this object &self, object &&other) noexcept -> object &
+	{
+		if (&self != &other)
+			self.m_object = std::exchange(other.m_object, nullptr);
+		return self; // NOLINT
+	}
+
+	// Copyable.  Note that this copies the entire UCL object.
+
+	object(object const &other)
+		: m_object([&] {
+			auto *uobj = ::ucl_object_copy(other.get_ucl_object());
+			if (uobj == nullptr)
+				throw std::runtime_error("failed to copy UCL object");
+			return uobj;
+		}())
+	{
+	}
+
+	auto operator=(this object &self, object const &other) -> object &
+	{
+		if (&self != &other)
+			self = object(other);
+		return self; // NOLINT
+	}
 
 	// Increase the refcount of this object.
-	[[nodiscard]] auto ref(this object const &self) -> object;
+	[[nodiscard]] auto ref(this object const &self) -> object
+	{
+		return {nihil::ucl::ref, self.get_ucl_object()};
+	}
 
 	// Return the type of this object.
-	[[nodiscard]] auto type(this object const &self) -> object_type;
+	[[nodiscard]] auto type(this object const &self) -> object_type
+	{
+		auto utype = ::ucl_object_type(self.get_ucl_object());
+		return static_cast<object_type>(utype);
+	}
 
 	// Return the underlying object.
-	[[nodiscard]] auto get_ucl_object(this object &self)
-		-> ::ucl_object_t *;
-
-	[[nodiscard]] auto get_ucl_object(this object const &self)
-		-> ::ucl_object_t const *;
+	[[nodiscard]] auto get_ucl_object(this object &self) -> ::ucl_object_t *
+	{
+		if (self.m_object == nullptr)
+			throw std::logic_error("attempt to access empty UCL object");
+		return self.m_object;
+	}
+
+	[[nodiscard]] auto get_ucl_object(this object const &self) -> ::ucl_object_t const *
+	{
+		if (self.m_object == nullptr)
+			throw std::logic_error("attempt to access empty UCL object");
+		return self.m_object;
+	}
 
 	// Return the key of this object.
-	[[nodiscard]] auto key(this object const &self) -> std::string_view;
+	[[nodiscard]] auto key(this object const &self) -> std::string_view
+	{
+		auto        dlen = std::size_t{};
+		auto const *dptr = ::ucl_object_keyl(self.get_ucl_object(), &dlen);
+		return {dptr, dlen};
+	}
 
 protected:
+	friend auto swap(object &a, object &b) noexcept -> void
+	{
+		std::swap(a.m_object, b.m_object);
+	}
+
+	// Helper to validate the type of a UCL object.  Throws type_mismatch if the
+	// type doesn't match, or else returns the pointer.
+	[[nodiscard]] static auto ensure_ucl_type(::ucl_object_t const *uobj, object_type type)
+		-> ::ucl_object_t const *
+	{
+		if (static_cast<object_type>(::ucl_object_type(uobj)) != type)
+			throw type_mismatch(type, static_cast<object_type>(::ucl_object_type(uobj)));
+		return uobj;
+	}
+
+	[[nodiscard]] static auto ensure_ucl_type(::ucl_object_t *uobj, object_type type)
+		-> ::ucl_object_t *
+	{
+		if (static_cast<object_type>(::ucl_object_type(uobj)) != type)
+			throw type_mismatch(type, static_cast<object_type>(::ucl_object_type(uobj)));
+		return uobj;
+	}
+
+private:
 	// The object we're wrapping.
 	::ucl_object_t *m_object = nullptr;
 
-	friend auto swap(object &a, object &b) -> void;
+	//
+	// Object comparison.
+	//
+
+	[[nodiscard]] friend auto
+	operator<=>(object const &lhs, object const &rhs) -> std::strong_ordering
+	{
+		auto cmp = ::ucl_object_compare(lhs.get_ucl_object(), rhs.get_ucl_object());
+
+		if (cmp < 0)
+			return std::strong_ordering::less;
+		else if (cmp > 0)
+			return std::strong_ordering::greater;
+		else
+			return std::strong_ordering::equal;
+	}
+
+	[[nodiscard]] friend auto operator==(object const &lhs, object const &rhs) -> bool
+	{
+		return (lhs <=> rhs) == std::strong_ordering::equal;
+	}
 };
 
-/***********************************************************************
- * Object comparison.
- */
-
-export [[nodiscard]] auto operator==(object const &lhs, object const &rhs)
-	-> bool;
-
-export [[nodiscard]] auto operator<=>(object const &lhs, object const &rhs)
-	-> std::strong_ordering;
-
 } // namespace nihil::ucl
diff --git a/nihil.ucl/tests/object.cc b/nihil.ucl/object.test.cc
index 3ad180e..557653c 100644
--- a/nihil.ucl/tests/object.cc
+++ b/nihil.ucl/object.test.cc
@@ -1,11 +1,10 @@
-/*
- * This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
 #include <ucl.h>
 
+import nihil.std;
 import nihil.ucl;
 
 TEST_CASE("ucl object: get_ucl_object", "[ucl]")
diff --git a/nihil.ucl/object_cast.ccm b/nihil.ucl/object_cast.ccm
index 3fa9eba..5a09085 100644
--- a/nihil.ucl/object_cast.ccm
+++ b/nihil.ucl/object_cast.ccm
@@ -1,17 +1,11 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <coroutine>
-#include <cstdlib>
-#include <expected>
-
 #include <ucl.h>
 
 export module nihil.ucl:object_cast;
 
+import nihil.std;
 import nihil.monad;
 import :type;
 import :object;
@@ -19,10 +13,9 @@ import :array;
 
 namespace nihil::ucl {
 
-/*
- * Ensure a UCL object is convertible to another type.  Throws type_mismatch
- * if not.
- */
+//
+// Ensure a UCL object is convertible to another type.
+//
 
 // Implementation for basic types.
 template<datatype To>
@@ -80,7 +73,7 @@ struct convert_check<array<T>>
 export template<datatype To>
 auto object_cast(object const &from) -> std::expected<To, type_mismatch>
 {
-	auto uobj = from.get_ucl_object();
+	auto const *uobj = from.get_ucl_object();
 
 	co_await convert_check<To>{}.check(uobj);
 	co_return To(nihil::ucl::ref, uobj);
diff --git a/nihil.ucl/tests/parse.cc b/nihil.ucl/parse.test.cc
index 43ce219..79a722d 100644
--- a/nihil.ucl/tests/parse.cc
+++ b/nihil.ucl/parse.test.cc
@@ -1,14 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <string>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
 
+import nihil.std;
 import nihil.ucl;
 
+namespace {
 TEST_CASE("ucl parse: iterate array", "[ucl]")
 {
 	using namespace std::literals;
@@ -53,3 +51,5 @@ TEST_CASE("ucl parse: iterate hash", "[ucl]")
 			REQUIRE(object_cast<string>(value) == "test");
 	}
 }
+
+} // anonymous namespace
diff --git a/nihil.ucl/parser.cc b/nihil.ucl/parser.cc
deleted file mode 100644
index 0a08670..0000000
--- a/nihil.ucl/parser.cc
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <expected>
-#include <functional>
-#include <string>
-
-#include <ucl.h>
-
-module nihil.ucl;
-
-import nihil.error;
-
-namespace nihil::ucl {
-
-auto make_parser(int flags) -> std::expected<parser, error>
-{
-	auto *p = ::ucl_parser_new(flags);
-	if (p != nullptr)
-		return p;
-
-	// TODO: Is there a way to get the actual error here?
-	return std::unexpected(error("failed to create parser"));
-}
-
-auto macro_handler::handle(unsigned char const *data,
-			   std::size_t len, void *ud)
-	-> bool
-{
-	auto handler = static_cast<macro_handler *>(ud);
-	auto string = std::string_view(
-			reinterpret_cast<char const *>(data),
-			len);
-	return handler->callback(string);
-}
-
-parser::parser(::ucl_parser *uclp)
-	: m_parser(uclp)
-{
-}
-
-parser::~parser()
-{
-	if (m_parser)
-		::ucl_parser_free(m_parser);
-}
-
-parser::parser(parser &&other) noexcept
-	: m_parser(std::exchange(other.m_parser, nullptr))
-	, m_macros(std::move(other.m_macros))
-{
-}
-
-auto parser::operator=(this parser &self, parser &&other) noexcept
-	-> parser &
-{
-	if (&self != &other) {
-		if (self.m_parser)
-			::ucl_parser_free(self.m_parser);
-
-		self.m_parser = std::exchange(other.m_parser, nullptr);
-		self.m_macros = std::move(other.m_macros);
-	}
-
-	return self;
-}
-
-auto parser::register_value(
-	this parser &self,
-	std::string_view variable,
-	std::string_view value)
-	-> void
-{
-	::ucl_parser_register_variable(
-		self.get_parser(),
-		std::string(variable).c_str(),
-		std::string(value).c_str());
-}
-
-auto parser::top(this parser &self) -> map<object>
-{
-	auto obj = ::ucl_parser_get_object(self.get_parser());
-	if (obj != nullptr)
-		// ucl_parser_get_object() refs the object for us.
-		return {noref, obj};
-
-	throw std::logic_error(
-		"attempt to call top() on an invalid ucl::parser");
-}
-
-auto parser::get_parser(this parser &self) -> ::ucl_parser *
-{
-	if (self.m_parser == nullptr)
-		throw std::logic_error("attempt to fetch a null ucl::parser");
-	
-	return self.m_parser;
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/parser.ccm b/nihil.ucl/parser.ccm
index 5fa3495..0100fda 100644
--- a/nihil.ucl/parser.ccm
+++ b/nihil.ucl/parser.ccm
@@ -1,21 +1,11 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <coroutine>
-#include <expected>
-#include <format>
-#include <functional>
-#include <memory>
-#include <string>
-#include <vector>
-
 #include <ucl.h>
 
 export module nihil.ucl:parser;
 
+import nihil.std;
 import nihil.monad;
 import :object;
 import :map;
@@ -28,79 +18,98 @@ export inline constexpr int parser_zerocopy = UCL_PARSER_ZEROCOPY;
 export inline constexpr int parser_no_time = UCL_PARSER_NO_TIME;
 
 // A macro handler.  This proxies the C API callback to the C++ API.
-using macro_callback_t = bool (std::string_view);
+using macro_callback_t = bool(std::string_view);
 
-struct macro_handler {
+struct macro_handler
+{
 	std::function<macro_callback_t> callback;
 
 	// Handle a callback from the C API.
-	static auto handle(
-		unsigned char const *data,
-		std::size_t len, void
-		*ud)
-	-> bool;
+	static auto handle(unsigned char const *data, std::size_t len, void *ud) -> bool
+	{
+		auto handler = static_cast<macro_handler *>(ud);
+		auto string = std::string_view(reinterpret_cast<char const *>(data), len);
+		return handler->callback(string);
+	}
 };
 
-/*
- * A UCL parser.  This wraps the C ucl_parser API.
- *
- * parser itself is not exported; use make_parser() to create one.
- */
-struct parser {
+// A UCL parser.  This wraps the C ucl_parser API.
+//
+// parser itself is not exported; use make_parser() to create one.
+struct parser
+{
 	// Create a parser from a UCL parser.
-	parser(::ucl_parser *);
+	explicit parser(::ucl_parser *uclp)
+		: m_parser(uclp)
+	{
+	}
 
 	// Destroy our parser when we're destroyed.
-	~parser();
+	~parser()
+	{
+		if (m_parser != nullptr)
+			::ucl_parser_free(m_parser);
+	}
 
 	// Not copyable.
 	parser(parser const &) = delete;
 	auto operator=(this parser &, parser const &) -> parser & = delete;
 
 	// Movable.
-	parser(parser &&) noexcept;
-	auto operator=(this parser &, parser &&) noexcept -> parser &;
+	parser(parser &&other) noexcept
+		: m_parser(std::exchange(other.m_parser, nullptr))
+		, m_macros(std::move(other.m_macros))
+	{
+	}
+
+	auto operator=(this parser &self, parser &&other) noexcept -> parser &
+	{
+		if (&self != &other) {
+			if (self.m_parser != nullptr)
+				::ucl_parser_free(self.m_parser);
+
+			self.m_parser = std::exchange(other.m_parser, nullptr);
+			self.m_macros = std::move(other.m_macros);
+		}
+
+		return self; // NOLINT
+	}
 
 	// Add a parser macro.  Unlike ucl_parser_register_macro, this doesn't
 	// take a userdata parameter; it's assumed the user will use lambda
 	// capture or similar if needed.
-	template<std::invocable<std::string_view> F>
-	auto register_macro(this parser &self,
-			    std::string_view name,
-			    F &&func)
-		-> void
-	requires (std::same_as<bool, std::invoke_result<F>>)
+
+	template <std::invocable<std::string_view> F>
+	auto register_macro(this parser &self, std::string_view name, F &&func) -> void
+	requires(std::same_as<bool, std::invoke_result<F>>)
 	{
-		auto handler = std::make_unique<macro_handler>(
-					std::forward<F>(func));
+		auto handler = std::make_unique<macro_handler>(std::forward<F>(func));
 
 		auto cname = std::string(name);
-		::ucl_parser_register_macro(
-			self.get_parser(), cname.c_str(),
-			&macro_handler::handle, handler.get());
+		::ucl_parser_register_macro(self.get_parser(), cname.c_str(),
+		                            &macro_handler::handle, handler.get());
 
 		self.m_macros.emplace_back(std::move(handler));
 	}
 
 	// Add a parser variable.
-	auto register_value(this parser &self,
-			    std::string_view variable,
-			    std::string_view value)
-		-> void;
+	auto
+	register_value(this parser &self, std::string_view variable, std::string_view value) -> void
+	{
+		::ucl_parser_register_variable(self.get_parser(), std::string(variable).c_str(),
+		                               std::string(value).c_str());
+	}
 
 	// Add data to the parser.
-	[[nodiscard]] auto add(this parser &self,
-			       std::ranges::contiguous_range auto &&data)
+	[[nodiscard]] auto add(this parser &self, std::ranges::contiguous_range auto &&data)
 		-> std::expected<void, error>
-	// Only bytes (chars) are permitted.
+		// Only bytes (chars) are permitted.
 	requires(sizeof(std::ranges::range_value_t<decltype(data)>) == 1)
 	{
 		auto *p = self.get_parser();
-		auto dptr = reinterpret_cast<unsigned char const *>(
-					std::ranges::data(data));
+		auto  dptr = reinterpret_cast<unsigned char const *>(std::ranges::data(data));
 
-		auto ret = ::ucl_parser_add_chunk(
-			p, dptr, std::ranges::size(data));
+		auto ret = ::ucl_parser_add_chunk(p, dptr, std::ranges::size(data));
 
 		if (ret == true)
 			return {};
@@ -108,23 +117,34 @@ struct parser {
 		return std::unexpected(error(::ucl_parser_get_error(p)));
 	}
 
-	[[nodiscard]] auto add(this parser &self,
-			       std::ranges::range auto &&data)
-		-> std::expected<void, error>
-	requires (!std::ranges::contiguous_range<decltype(data)>)
+	[[nodiscard]] auto
+	add(this parser &self, std::ranges::range auto &&data) -> std::expected<void, error>
+	requires(!std::ranges::contiguous_range<decltype(data)>)
 	{
-		auto cdata = std::vector<char>(
-				std::from_range,
-				std::forward<decltype(data)>(data));
+		auto cdata = std::vector<char>(std::from_range, std::forward<decltype(data)>(data));
 		co_await self.add(std::move(cdata));
 		co_return {};
 	}
 
 	// Return the top object of this parser.
-	[[nodiscard]] auto top(this parser &self) -> map<object>;
+	[[nodiscard]] auto top(this parser &self) -> map<object>
+	{
+		auto *obj = ::ucl_parser_get_object(self.get_parser());
+		if (obj != nullptr)
+			// ucl_parser_get_object() refs the object for us.
+			return {noref, obj};
+
+		throw std::logic_error("attempt to call top() on an invalid ucl::parser");
+	}
 
 	// Return the stored parser object.
-	[[nodiscard]] auto get_parser(this parser &self) -> ::ucl_parser *;
+	[[nodiscard]] auto get_parser(this parser &self) -> ::ucl_parser *
+	{
+		if (self.m_parser == nullptr)
+			throw std::logic_error("attempt to fetch a null ucl::parser");
+
+		return self.m_parser;
+	}
 
 private:
 	// The parser object.  Should never be null, unless we've been
@@ -137,22 +157,26 @@ private:
 };
 
 // Create a parser with the given flags.
-export [[nodiscard]] auto
-make_parser(int flags = 0) -> std::expected<parser, error>;
+export [[nodiscard]] auto make_parser(int flags = 0) -> std::expected<parser, error>
+{
+	auto *p = ::ucl_parser_new(flags);
+	if (p != nullptr)
+		return {parser(p)};
+
+	// TODO: Is there a way to get the actual error here?
+	return std::unexpected(error("failed to create parser"));
+}
 
 // Utility function to parse something and return the top-level object.
 export [[nodiscard]] auto
-parse(int flags, std::ranges::range auto &&data)
-	-> std::expected<map<object>, error> 
+parse(int flags, std::ranges::range auto &&data) -> std::expected<map<object>, error>
 {
 	auto p = co_await make_parser(flags);
 	co_await p.add(std::forward<decltype(data)>(data));
 	co_return p.top();
 }
 
-export [[nodiscard]] auto
-parse(std::ranges::range auto &&data)
-	-> std::expected<map<object>, error> 
+export [[nodiscard]] auto parse(std::ranges::range auto &&data) -> std::expected<map<object>, error>
 {
 	co_return co_await parse(0, std::forward<decltype(data)>(data));
 }
diff --git a/nihil.ucl/real.cc b/nihil.ucl/real.cc
deleted file mode 100644
index 6d9e082..0000000
--- a/nihil.ucl/real.cc
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <cassert>
-#include <compare>
-#include <cstdlib>
-#include <expected>
-#include <string>
-#include <system_error>
-
-#include <ucl.h>
-
-module nihil.ucl;
-
-import nihil.error;
-
-namespace nihil::ucl {
-
-auto make_real(real::contained_type value)
-	-> std::expected<real, error>
-{
-	auto *uobj = ::ucl_object_fromdouble(value);
-	if (uobj == nullptr)
-		return std::unexpected(error(
-			errc::failed_to_create_object,
-			error(std::errc(errno))));
-
-	return real(noref, uobj);
-}
-
-real::real()
-	: real(0)
-{
-}
-
-real::real(contained_type value)
-	: real(noref, [&] {
-		auto *uobj = ::ucl_object_fromdouble(value);
-		if (uobj == nullptr)
-			throw std::system_error(
-				std::make_error_code(std::errc(errno)));
-		return uobj;
-	}())
-{
-}
-
-real::real(ref_t, ::ucl_object_t const *uobj)
-	: object(nihil::ucl::ref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != real::ucl_type)
-			throw type_mismatch(real::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-real::real(noref_t, ::ucl_object_t *uobj)
-	: object(nihil::ucl::noref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != real::ucl_type)
-			throw type_mismatch(real::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-auto real::value(this real const &self) -> contained_type
-{
-	auto v = contained_type{};
-	auto const *uobj = self.get_ucl_object();
-
-	if (::ucl_object_todouble_safe(uobj, &v))
-		return v;
-
-	std::abort();
-}
-
-auto operator== (real const &a, real const &b) -> bool
-{
-	return a.value() == b.value();
-}
-
-auto operator<=> (real const &a, real const &b) -> std::partial_ordering
-{
-	return a.value() <=> b.value();
-}
-
-auto operator== (real const &a, real::contained_type b) -> bool
-{
-	return a.value() == b;
-}
-
-auto operator<=> (real const &a, real::contained_type b)
-	-> std::partial_ordering
-{
-	return a.value() <=> b;
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/real.ccm b/nihil.ucl/real.ccm
index f425a9a..b432617 100644
--- a/nihil.ucl/real.ccm
+++ b/nihil.ucl/real.ccm
@@ -1,78 +1,106 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <compare>
-#include <expected>
-#include <format>
-#include <utility>
-
 #include <ucl.h>
 
 export module nihil.ucl:real;
 
+import nihil.std;
+import nihil.core;
 import :object;
 import :type;
 
 namespace nihil::ucl {
 
-export struct real final : object {
+export struct real final : object
+{
 	using contained_type = double;
 
-	inline static constexpr object_type ucl_type = object_type::real;
+	static constexpr object_type ucl_type = object_type::real;
 
-	/*
-	 * Create a real holding the value 0.  Throws std::system_error
-	 * on failure.
-	 */
-	real();
+	// Create a real holding the value 0.  Throws std::system_error
+	// on failure.
+	real()
+		: real(0)
+	{
+	}
 
-	/*
-	 * Create a real holding a specific value.  Throws std::system_error
-	 * on failure.
-	 */
-	explicit real(contained_type value);
+	// Create a real holding a specific value.  Throws std::system_error
+	// on failure.
+	explicit real(contained_type value)
+		: real(noref, [&] {
+			auto *uobj = ::ucl_object_fromdouble(value);
+			if (uobj == nullptr)
+				throw std::system_error(std::make_error_code(sys_error()));
+			return uobj;
+		}())
+	{
+	}
 
-	/*
-	 * Create a new real from a UCL object.  Throws type_mismatch
-	 * on failure.
-	 */
-	real(ref_t, ::ucl_object_t const *uobj);
-	real(noref_t, ::ucl_object_t *uobj);
+	// Create a new real from a UCL object.  Throws type_mismatch
+	// on failure.
+	real(ref_t, ::ucl_object_t const *uobj)
+		: object(nihil::ucl::ref, ensure_ucl_type(uobj, real::ucl_type))
+	{
+	}
+
+	real(noref_t, ::ucl_object_t *uobj)
+		: object(nihil::ucl::noref, ensure_ucl_type(uobj, real::ucl_type))
+	{
+	}
 
 	// Return the value of this real.
-	[[nodiscard]] auto value(this real const &self) -> contained_type;
-};
+	[[nodiscard]] auto value(this real const &self) -> contained_type
+	{
+		auto        v = contained_type{};
+		auto const *uobj = self.get_ucl_object();
+
+		if (::ucl_object_todouble_safe(uobj, &v))
+			return v;
 
-/*
- * Real constructors.  These return an error instead of throwing.
- */
+		throw std::runtime_error("ucl_object_todouble_safe failed");
+	}
 
-export [[nodiscard]] auto
-make_real(real::contained_type = 0) -> std::expected<real, error>;
+private:
+	//
+	// Comparison operators.
+	//
 
-/*
- * Comparison operators.
- */
+	[[nodiscard]] friend auto operator==(real const &a, real const &b) -> bool
+	{
+		return a.value() == b.value();
+	}
 
-export [[nodiscard]] auto operator== (real const &a, real const &b) -> bool;
+	[[nodiscard]] friend auto operator<=>(real const &a, real const &b) -> std::partial_ordering
+	{
+		return a.value() <=> b.value();
+	}
 
-export [[nodiscard]] auto operator== (real const &a,
-				      real::contained_type b) -> bool;
+	[[nodiscard]] friend auto operator==(real const &a, real::contained_type b) -> bool
+	{
+		return a.value() == b;
+	}
 
-export [[nodiscard]] auto operator<=> (real const &a, real const &b)
-	-> std::partial_ordering;
+	[[nodiscard]] friend auto
+	operator<=>(real const &a, real::contained_type b) -> std::partial_ordering
+	{
+		return a.value() <=> b;
+	}
+};
 
-export [[nodiscard]] auto operator<=> (real const &a, real::contained_type b)
-	-> std::partial_ordering;
+// Real constructor.  This returns an error instead of throwing.
+export [[nodiscard]] auto make_real(real::contained_type value = 0) -> std::expected<real, error>
+{
+	auto *uobj = ::ucl_object_fromdouble(value);
+	if (uobj == nullptr)
+		return std::unexpected(error(errc::failed_to_create_object, error(sys_error())));
 
-/*
- * Literal operator.
- */
+	return real(noref, uobj);
+}
+
+// Literal operator.
 inline namespace literals {
-export constexpr auto operator""_ucl (long double d) -> real
+export constexpr auto operator""_ucl(long double d) -> real
 {
 	if (d > static_cast<long double>(std::numeric_limits<double>::max()) ||
 	    d < static_cast<long double>(std::numeric_limits<double>::min()))
@@ -80,32 +108,31 @@ export constexpr auto operator""_ucl (long double d) -> real
 
 	return real(static_cast<double>(d));
 }
-} // namespace nihil::ucl::literals
+} // namespace literals
 
 } // namespace nihil::ucl
 
-namespace nihil { inline namespace literals {
-	export using namespace ::nihil::ucl::literals;
-}} // namespace nihil::literals
+namespace nihil {
+inline namespace literals {
+export using namespace ::nihil::ucl::literals;
+}
+} // namespace nihil
 
-/*
- * std::formatter for a real.  This provides the same format operations
- * as std::formatter<double>;
- */
-export template<>
+// std::formatter for a real.  This provides the same format operations
+// as std::formatter<double>;
+export template <>
 struct std::formatter<nihil::ucl::real, char>
 {
 	std::formatter<double> base_formatter;
 
-	template<class ParseContext>
-	constexpr ParseContext::iterator parse(ParseContext& ctx)
+	template <class ParseContext>
+	constexpr auto parse(ParseContext &ctx) -> ParseContext::iterator
 	{
 		return base_formatter.parse(ctx);
 	}
 
-	template<class FmtContext>
-	FmtContext::iterator format(nihil::ucl::real const &o,
-				    FmtContext& ctx) const
+	template <class FmtContext>
+	auto format(nihil::ucl::real const &o, FmtContext &ctx) const -> FmtContext::iterator
 	{
 		return base_formatter.format(o.value(), ctx);
 	}
diff --git a/nihil.ucl/tests/real.cc b/nihil.ucl/real.test.cc
index 421917e..e880d9a 100644
--- a/nihil.ucl/tests/real.cc
+++ b/nihil.ucl/real.test.cc
@@ -1,16 +1,13 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <concepts>
-#include <string>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
 #include <ucl.h>
 
+import nihil.std;
 import nihil.ucl;
 
+namespace {
 TEST_CASE("ucl: real: invariants", "[ucl]")
 {
 	using namespace nihil::ucl;
@@ -32,12 +29,12 @@ TEST_CASE("ucl: real: constructor", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("default") {
+	SECTION ("default") {
 		auto r = real();
 		REQUIRE(r == 0);
 	}
 
-	SECTION("with value") {
+	SECTION ("with value") {
 		auto r = real(42.1);
 		REQUIRE_THAT(r.value(), Catch::Matchers::WithinRel(42.1));
 	}
@@ -45,7 +42,7 @@ TEST_CASE("ucl: real: constructor", "[ucl]")
 
 TEST_CASE("ucl: real: literal", "[ucl]")
 {
-	SECTION("with namespace nihil::ucl::literals") {
+	SECTION ("with namespace nihil::ucl::literals") {
 		using namespace nihil::ucl::literals;
 
 		auto r = 42.5_ucl;
@@ -53,7 +50,7 @@ TEST_CASE("ucl: real: literal", "[ucl]")
 		REQUIRE_THAT(r.value(), Catch::Matchers::WithinRel(42.5));
 	}
 
-	SECTION("with namespace nihil::literals") {
+	SECTION ("with namespace nihil::literals") {
 		using namespace nihil::literals;
 
 		auto r = 42.5_ucl;
@@ -66,8 +63,8 @@ TEST_CASE("ucl: real: construct from UCL object", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("ref, correct type") {
-		auto uobj = ::ucl_object_fromdouble(42);
+	SECTION ("ref, correct type") {
+		auto *uobj = ::ucl_object_fromdouble(42);
 
 		auto r = real(ref, uobj);
 		REQUIRE(r == 42);
@@ -75,23 +72,23 @@ TEST_CASE("ucl: real: construct from UCL object", "[ucl]")
 		::ucl_object_unref(uobj);
 	}
 
-	SECTION("noref, correct type") {
-		auto uobj = ::ucl_object_fromdouble(42);
+	SECTION ("noref, correct type") {
+		auto *uobj = ::ucl_object_fromdouble(42);
 
 		auto r = real(noref, uobj);
 		REQUIRE(r == 42);
 	}
 
-	SECTION("ref, wrong type") {
-		auto uobj = ::ucl_object_fromint(42);
+	SECTION ("ref, wrong type") {
+		auto *uobj = ::ucl_object_fromint(42);
 
 		REQUIRE_THROWS_AS(real(ref, uobj), type_mismatch);
 
 		::ucl_object_unref(uobj);
 	}
 
-	SECTION("noref, wrong type") {
-		auto uobj = ::ucl_object_fromint(42);
+	SECTION ("noref, wrong type") {
+		auto *uobj = ::ucl_object_fromint(42);
 
 		REQUIRE_THROWS_AS(real(noref, uobj), type_mismatch);
 
@@ -103,12 +100,12 @@ TEST_CASE("ucl: real: make_real", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("default value") {
+	SECTION ("default value") {
 		auto i = make_real().value();
 		REQUIRE(i == 0);
 	}
 
-	SECTION("explicit value") {
+	SECTION ("explicit value") {
 		auto i = make_real(42).value();
 		REQUIRE(i == 42);
 	}
@@ -117,7 +114,7 @@ TEST_CASE("ucl: real: make_real", "[ucl]")
 TEST_CASE("ucl: real: swap", "[ucl]")
 {
 	// do not add using namespace nihil::ucl
-	
+
 	auto r1 = nihil::ucl::real(1);
 	auto r2 = nihil::ucl::real(2);
 
@@ -139,15 +136,15 @@ TEST_CASE("ucl: real: key()", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("parsed with key") {
+	SECTION ("parsed with key") {
 		auto obj = parse("a_real = 42.5").value();
 		auto r = object_cast<real>(obj["a_real"]).value();
 		REQUIRE(r.key() == "a_real");
 	}
 
-	SECTION("bare real, no key") {
+	SECTION ("bare real, no key") {
 		auto i = 42.5_ucl;
-		REQUIRE(i.key() == "");
+		REQUIRE(i.key().empty() == true);
 	}
 }
 
@@ -157,22 +154,22 @@ TEST_CASE("ucl: real: comparison", "[ucl]")
 
 	auto i = nihil::ucl::real(42.5);
 
-	SECTION("operator==") {
+	SECTION ("operator==") {
 		REQUIRE(i == 42.5);
 		REQUIRE(i == 42.5_ucl);
 	}
 
-	SECTION("operator!=") {
+	SECTION ("operator!=") {
 		REQUIRE(i != 1);
 		REQUIRE(i != 1._ucl);
 	}
 
-	SECTION("operator<") {
+	SECTION ("operator<") {
 		REQUIRE(i < 43);
 		REQUIRE(i < 43._ucl);
 	}
 
-	SECTION("operator>") {
+	SECTION ("operator>") {
 		REQUIRE(i > 1);
 		REQUIRE(i > 1._ucl);
 	}
@@ -186,8 +183,7 @@ TEST_CASE("ucl: real: parse", "[ucl]")
 
 	auto v = obj["value"];
 	REQUIRE(v.key() == "value");
-	REQUIRE_THAT(object_cast<real>(v).value().value(),
-		     Catch::Matchers::WithinRel(42.1));
+	REQUIRE_THAT(object_cast<real>(v).value().value(), Catch::Matchers::WithinRel(42.1));
 }
 
 TEST_CASE("ucl: real: parse and emit", "[ucl]")
@@ -206,12 +202,12 @@ TEST_CASE("ucl: real: format", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("bare real") {
+	SECTION ("bare real") {
 		auto str = std::format("{}", 42.5_ucl);
 		REQUIRE(str == "42.5");
 	}
 
-	SECTION("parsed real") {
+	SECTION ("parsed real") {
 		auto obj = parse("real = 42.5;").value();
 		auto r = object_cast<real>(obj["real"]).value();
 
@@ -219,7 +215,7 @@ TEST_CASE("ucl: real: format", "[ucl]")
 		REQUIRE(str == "42.5");
 	}
 
-	SECTION("with format string") {
+	SECTION ("with format string") {
 		auto str = std::format("{:10.5f}", 42.5_ucl);
 		REQUIRE(str == "  42.50000");
 	}
@@ -229,14 +225,14 @@ TEST_CASE("ucl: real: print to ostream", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	SECTION("bare real") {
+	SECTION ("bare real") {
 		auto strm = std::ostringstream();
 		strm << 42.5_ucl;
 
 		REQUIRE(strm.str() == "42.5");
 	}
 
-	SECTION("parsed real") {
+	SECTION ("parsed real") {
 		auto obj = parse("real = 42.5;").value();
 		auto i = object_cast<real>(obj["real"]).value();
 
@@ -246,3 +242,4 @@ TEST_CASE("ucl: real: print to ostream", "[ucl]")
 		REQUIRE(strm.str() == "42.5");
 	}
 }
+} // anonymous namespace
diff --git a/nihil.ucl/string.cc b/nihil.ucl/string.cc
deleted file mode 100644
index 67e97f4..0000000
--- a/nihil.ucl/string.cc
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <cstdlib>
-#include <expected>
-#include <iosfwd>
-#include <string>
-#include <system_error>
-
-#include <ucl.h>
-
-module nihil.ucl;
-
-import nihil.error;
-
-namespace nihil::ucl {
-
-auto make_string() -> std::expected<string, error>
-{
-	return make_string(std::string_view(""));
-}
-
-auto make_string(char const *s) -> std::expected<string, error>
-{
-	return make_string(std::string_view(s));
-}
-
-auto make_string(std::string_view s) -> std::expected<string, error>
-{
-	auto *uobj = ::ucl_object_fromstring_common(
-			s.data(), s.size(), UCL_STRING_RAW);
-
-	if (uobj == nullptr)
-		return std::unexpected(error(
-			errc::failed_to_create_object,
-			error(std::errc(errno))));
-
-	return string(noref, uobj);
-}
-
-string::string(ref_t, ::ucl_object_t const *uobj)
-	: object(nihil::ucl::ref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != string::ucl_type)
-			throw type_mismatch(string::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-string::string(noref_t, ::ucl_object_t *uobj)
-	: object(nihil::ucl::noref, [&] {
-		auto actual_type = static_cast<object_type>(
-					::ucl_object_type(uobj));
-		if (actual_type != string::ucl_type)
-			throw type_mismatch(string::ucl_type, actual_type);
-		return uobj;
-	}())
-{
-}
-
-string::string()
-	: string(std::string_view(""))
-{}
-
-string::string(std::string_view value)
-	: string(noref, [&] {
-		auto *uobj = ::ucl_object_fromstring_common(
-				value.data(), value.size(), UCL_STRING_RAW);
-		if (uobj == nullptr)
-			throw std::system_error(
-				std::make_error_code(std::errc(errno)));
-		return uobj;
-	}())
-{
-}
-
-string::string(char const *value)
-	: string(std::string_view(value))
-{
-}
-
-auto string::value(this string const &self) -> contained_type
-{
-	char const *dptr{};
-	std::size_t dlen;
-
-	auto const *uobj = self.get_ucl_object();
-	if (::ucl_object_tolstring_safe(uobj, &dptr, &dlen))
-		return {dptr, dlen};
-
-	// This should never fail.
-	std::abort();
-}
-
-auto string::size(this string const &self) -> size_type
-{
-	return self.value().size();
-}
-
-auto string::empty(this string const &self) -> bool
-{
-	return self.size() == 0;
-}
-
-auto string::data(this string const &self) -> pointer
-{
-	char const *dptr{};
-
-	auto const *uobj = self.get_ucl_object();
-	if (::ucl_object_tostring_safe(uobj, &dptr))
-		return dptr;
-
-	// This should never fail.
-	std::abort();
-}
-
-auto string::begin(this string const &self) -> iterator
-{
-	return self.data();
-}
-
-auto string::end(this string const &self) -> iterator
-{
-	return self.data() + self.size();
-}
-
-auto operator== (string const &a, string const &b)
-	-> bool
-{
-	return a.value() == b.value();
-}
-
-auto operator<=> (string const &a, string const &b)
-	-> std::strong_ordering
-{
-	return a.value() <=> b.value();
-}
-
-/*
- * For convenience, allow comparison with C++ strings without having to
- * construct a temporary UCL object.
- */
-
-auto operator==(string const &lhs, std::string_view rhs) -> bool
-{
-	return lhs.value() == rhs;
-}
-
-auto operator<=>(string const &lhs, std::string_view rhs)
-	-> std::strong_ordering
-{
-	return lhs.value() <=> rhs;
-}
-
-auto operator==(string const &lhs, std::string const &rhs) -> bool
-{
-	return lhs == std::string_view(rhs);
-}
-
-auto operator<=>(string const &lhs, std::string const &rhs)
-	-> std::strong_ordering
-{
-	return lhs <=> std::string_view(rhs);
-}
-
-auto operator==(string const &lhs, char const *rhs) -> bool
-{
-	return lhs == std::string_view(rhs);
-}
-
-auto operator<=>(string const &lhs, char const *rhs)
-	-> std::strong_ordering
-{
-	return lhs <=> std::string_view(rhs);
-}
-
-auto operator<<(std::ostream &strm, string const &s) -> std::ostream &
-{
-	return strm << s.value();
-}
-
-} // namespace nihil::ucl
diff --git a/nihil.ucl/string.ccm b/nihil.ucl/string.ccm
index c757bf1..4b46e39 100644
--- a/nihil.ucl/string.ccm
+++ b/nihil.ucl/string.ccm
@@ -1,27 +1,21 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <cstdlib>
-#include <expected>
-#include <format>
-#include <iosfwd>
-#include <string>
-
 #include <ucl.h>
 
 export module nihil.ucl:string;
 
+import nihil.std;
+import nihil.core;
 import :object;
 import :type;
 
 namespace nihil::ucl {
 
-export struct string final : object {
+export struct string final : object
+{
 	using contained_type = std::string_view;
-	inline static constexpr object_type ucl_type = object_type::string;
+	static constexpr object_type ucl_type = object_type::string;
 
 	// string is a container of char
 	using value_type = char const;
@@ -31,159 +25,236 @@ export struct string final : object {
 	using pointer = value_type *;
 	using iterator = pointer;
 
-	/*
-	 * Create a new empty string.  Throws std::system_error on failure.
-	 */
-	string();
-
-	/*
-	 * Create a string from a value.  Throws std::system_error on failure.
-	 */
-	explicit string(std::string_view);
-
-	/*
-	 * Create a string from a C literal.  Throws std::system_error
-	 * on failure.
-	 */
-	explicit string(char const *);
-
-	/*
-	 * Create a string from a contiguous range.  The range's value type
-	 * must be char.  Throws std::system_error on failure.
-	 */
-	template<std::ranges::contiguous_range Range>
-	requires (!std::same_as<std::string_view, Range> &&
-		  std::same_as<char, std::ranges::range_value_t<Range>>)
-	explicit string(Range &&range)
-		: string(std::string_view(std::ranges::begin(range),
-					  std::ranges::end(range)))
-	{}
-
-	/*
-	 * Create a string from a non-contiguous range.  This requires a
-	 * temporary value due to limitations of the UCL C API.
-	 */
-	template<std::ranges::range Range>
-	requires (!std::ranges::contiguous_range<Range> &&
-		  std::same_as<char, std::ranges::range_value_t<Range>>)
-	explicit string(Range &&range)
-		: string(std::string(std::from_range, range))
-	{}
-
-	/*
-	 * Create a string from an iterator pair.  The iterator's value type
-	 * must be char.  If the iterator pair is not contiguous, the value
-	 * will be copied to a temporary first.
-	 *
-	 * Throws std::system_error on failure.
-	 */
-	template<std::input_iterator Iterator>
-	requires (std::same_as<char, std::iter_value_t<Iterator>>)
+	// Create a new empty string.  Throws std::system_error on failure.
+	string()
+		: string(std::string_view(""))
+	{
+	}
+
+	// Create a string from a value.  Throws std::system_error on failure.
+	explicit string(std::string_view value)
+		: string(noref, [&] {
+			auto *uobj = ::ucl_object_fromstring_common(value.data(), value.size(),
+		                                                    UCL_STRING_RAW);
+			if (uobj == nullptr)
+				throw std::system_error(std::make_error_code(sys_error()));
+			return uobj;
+		}())
+	{
+	}
+
+	// Create a string from a C literal.  Throws std::system_error
+	// on failure.
+	explicit string(char const *value)
+		: string(std::string_view(value))
+	{
+	}
+
+	// Create a string from a contiguous range.  The range's value type
+	// must be char.  Throws std::system_error on failure.
+	template <std::ranges::contiguous_range Range>
+	requires(!std::same_as<std::string_view, Range> &&
+	         std::same_as<char, std::ranges::range_value_t<Range>>)
+	explicit string(Range const &range)
+		: string(std::string_view(std::ranges::begin(range), std::ranges::end(range)))
+	{
+	}
+
+	// Create a string from a non-contiguous range.  This requires a
+	// temporary value due to limitations of the UCL C API.
+	template <std::ranges::range Range>
+	requires(!std::ranges::contiguous_range<Range> &&
+	         std::same_as<char, std::ranges::range_value_t<Range>>)
+	explicit string(Range range)
+		: string(std::string(std::from_range, std::forward<Range>(range)))
+	{
+	}
+
+	// Create a string from an iterator pair.  The iterator's value type
+	// must be char.  If the iterator pair is not contiguous, the value
+	// will be copied to a temporary first.
+	//
+	// Throws std::system_error on failure.
+	template <std::input_iterator Iterator>
+	requires(std::same_as<char, std::iter_value_t<Iterator>>)
 	string(Iterator first, Iterator last)
 		: string(std::ranges::subrange(first, last))
-	{}
+	{
+	}
+
+	// Create a new string from a UCL object.  Throws type_mismatch
+	// on failure.
+	string(ref_t, ::ucl_object_t const *uobj)
+		: object(nihil::ucl::ref, ensure_ucl_type(uobj, string::ucl_type))
+	{
+	}
 
-	/*
-	 * Create a new string from a UCL object.  Throws type_mismatch
-	 * on failure.
-	 */
-	string(ref_t, ::ucl_object_t const *uobj);
-	string(noref_t, ::ucl_object_t *uobj);
+	string(noref_t, ::ucl_object_t *uobj)
+		: object(nihil::ucl::noref, ensure_ucl_type(uobj, string::ucl_type))
+	{
+	}
 
 	// Return the value of this string.
-	[[nodiscard]] auto value(this string const &self) -> contained_type;
+	[[nodiscard]] auto value(this string const &self) -> contained_type
+	{
+		char const *dptr{};
+		std::size_t dlen{};
+
+		auto const *uobj = self.get_ucl_object();
+		if (::ucl_object_tolstring_safe(uobj, &dptr, &dlen))
+			return {dptr, dlen};
+
+		throw std::runtime_error("ucl_object_tolstring_safe() failed");
+	}
 
 	// Return the size of this string.
-	[[nodiscard]] auto size(this string const &self) -> size_type;
+	[[nodiscard]] auto size(this string const &self) -> size_type
+	{
+		return self.value().size();
+	}
 
 	// Test if this string is empty.
-	[[nodiscard]] auto empty(this string const &self) -> bool;
+	[[nodiscard]] auto empty(this string const &self) -> bool
+	{
+		return self.size() == 0;
+	}
 
 	// Access this string's data
-	[[nodiscard]] auto data(this string const &self) -> pointer;
+	[[nodiscard]] auto data(this string const &self) -> pointer
+	{
+		char const *dptr{};
+
+		auto const *uobj = self.get_ucl_object();
+		if (::ucl_object_tostring_safe(uobj, &dptr))
+			return dptr;
+
+		throw std::runtime_error("ucl_object_tostring_safe() failed");
+	}
 
 	// Iterator access
-	[[nodiscard]] auto begin(this string const &self) -> iterator;
-	[[nodiscard]] auto end(this string const &self) -> iterator;
-};
+	[[nodiscard]] auto begin(this string const &self) -> iterator
+	{
+		return self.data();
+	}
 
-/*
- * String constructors.  These return an error instead of throwing.
- */
+	[[nodiscard]] auto end(this string const &self) -> iterator
+	{
+		return self.data() + self.size();
+	}
 
-// Empty string
-export [[nodiscard]] auto
-make_string() -> std::expected<string, error>;
+private:
+	//
+	// Comparison operators.
+	//
+
+	[[nodiscard]] friend auto operator==(string const &a, string const &b) -> bool
+	{
+		return a.value() == b.value();
+	}
+
+	[[nodiscard]] friend auto
+	operator<=>(string const &a, string const &b) -> std::strong_ordering
+	{
+		return a.value() <=> b.value();
+	}
+
+	// For convenience, allow comparison with C++ strings without having to
+	// construct a temporary UCL object.
+
+	[[nodiscard]] friend auto operator==(string const &lhs, std::string_view rhs) -> bool
+	{
+		return lhs.value() == rhs;
+	}
+
+	[[nodiscard]] friend auto
+	operator<=>(string const &lhs, std::string_view rhs) -> std::strong_ordering
+	{
+		return lhs.value() <=> rhs;
+	}
+
+	[[nodiscard]] friend auto operator==(string const &lhs, std::string const &rhs) -> bool
+	{
+		return lhs == std::string_view(rhs);
+	}
+
+	[[nodiscard]] friend auto
+	operator<=>(string const &lhs, std::string const &rhs) -> std::strong_ordering
+	{
+		return lhs <=> std::string_view(rhs);
+	}
+
+	[[nodiscard]] friend auto operator==(string const &lhs, char const *rhs) -> bool
+	{
+		return lhs == std::string_view(rhs);
+	}
+
+	[[nodiscard]] friend auto
+	operator<=>(string const &lhs, char const *rhs) -> std::strong_ordering
+	{
+		return lhs <=> std::string_view(rhs);
+	}
+
+	// Stream output.
+	friend auto operator<<(std::ostream &strm, string const &s) -> std::ostream &
+	{
+		return strm << s.value();
+	}
+};
+
+//
+// String constructors.  These return an error instead of throwing.
+//
 
 // From string_view
-export [[nodiscard]] auto
-make_string(std::string_view) -> std::expected<string, error>;
+export [[nodiscard]] auto make_string(std::string_view s) -> std::expected<string, error>
+{
+	auto *uobj = ::ucl_object_fromstring_common(s.data(), s.size(), UCL_STRING_RAW);
+
+	if (uobj == nullptr)
+		return std::unexpected(error(errc::failed_to_create_object, error(sys_error())));
+
+	return string(noref, uobj);
+}
+
+// Empty string
+export [[nodiscard]] auto make_string() -> std::expected<string, error>
+{
+	return make_string(std::string_view(""));
+}
 
 // From C literal
-export [[nodiscard]] auto
-make_string(char const *) -> std::expected<string, error>;
+export [[nodiscard]] auto make_string(char const *s) -> std::expected<string, error>
+{
+	return make_string(std::string_view(s));
+}
 
 // From contiguous range
-export template<std::ranges::contiguous_range Range>
-requires (!std::same_as<std::string_view, Range> &&
-	  std::same_as<char, std::ranges::range_value_t<Range>>)
+export template <std::ranges::contiguous_range Range>
+requires(!std::same_as<std::string_view, Range> &&
+         std::same_as<char, std::ranges::range_value_t<Range>>)
 [[nodiscard]] auto make_string(Range &&range)
 {
-	return make_string(std::string_view(range));
+	return make_string(std::string_view(std::forward<Range>(range)));
 }
 
 // From non-contiguous range
-export template<std::ranges::range Range>
-requires (!std::ranges::contiguous_range<Range> &&
-	  std::same_as<char, std::ranges::range_value_t<Range>>)
+export template <std::ranges::range Range>
+requires(!std::ranges::contiguous_range<Range> &&
+         std::same_as<char, std::ranges::range_value_t<Range>>)
 [[nodiscard]] auto make_string(Range &&range)
 {
-	return make_string(std::string(std::from_range, range));
+	return make_string(std::string(std::from_range, std::forward<Range>(range)));
 }
 
 // From iterator pair
-export template<std::input_iterator Iterator>
-requires (std::same_as<char, std::iter_value_t<Iterator>>)
+export template <std::input_iterator Iterator>
+requires(std::same_as<char, std::iter_value_t<Iterator>>)
 [[nodiscard]] auto make_string(Iterator first, Iterator last)
 {
 	return make_string(std::ranges::subrange(first, last));
 }
 
 /*
- * Comparison operators.
- */
-
-export [[nodiscard]] auto operator== (string const &a, string const &b) -> bool;
-export [[nodiscard]] auto operator<=> (string const &a, string const &b)
-	-> std::strong_ordering;
-
-/*
- * For convenience, allow comparison with C++ strings without having to
- * construct a temporary UCL object.
- */
-
-export [[nodiscard]] auto operator==(string const &lhs,
-				     std::string_view rhs) -> bool;
-
-export [[nodiscard]] auto operator==(string const &lhs,
-				     std::string const &rhs) -> bool;
-
-export [[nodiscard]] auto operator==(string const &lhs,
-				     char const *rhs) -> bool;
-
-export [[nodiscard]] auto operator<=>(string const &lhs,
-				      std::string_view rhs)
-	-> std::strong_ordering;
-
-export [[nodiscard]] auto operator<=>(string const &lhs,
-				      std::string const &rhs)
-	-> std::strong_ordering;
-
-export [[nodiscard]] auto operator<=>(string const &lhs,
-				      char const *rhs)
-	-> std::strong_ordering;
-
-/*
  * Print a string to a stream.
  */
 export auto operator<<(std::ostream &, string const &) -> std::ostream &;
@@ -192,37 +263,37 @@ export auto operator<<(std::ostream &, string const &) -> std::ostream &;
  * Literal operator.
  */
 inline namespace literals {
-	export constexpr auto operator""_ucl (char const *s, std::size_t n)
-		-> string
-	{
-		return string(std::string_view(s, n));
-	}
-} // namespace nihil::ucl::literals
+export constexpr auto operator""_ucl(char const *s, std::size_t n) -> string
+{
+	return string(std::string_view(s, n));
+}
+} // namespace literals
 
 } // namespace nihil::ucl
 
-namespace nihil { inline namespace literals {
-	export using namespace ::nihil::ucl::literals;
-}} // namespace nihil::literals
+namespace nihil {
+inline namespace literals {
+export using namespace ::nihil::ucl::literals;
+}
+} // namespace nihil
 
 /*
  * std::formatter for a string.  This provides the same format operations
  * as std::formatter<std::string_view>.
  */
-export template<>
+export template <>
 struct std::formatter<nihil::ucl::string, char>
 {
 	std::formatter<std::string_view> base_formatter;
 
-	template<class ParseContext>
-	constexpr ParseContext::iterator parse(ParseContext& ctx)
+	template <class ParseContext>
+	constexpr auto parse(ParseContext &ctx) -> ParseContext::iterator
 	{
 		return base_formatter.parse(ctx);
 	}
 
-	template<class FmtContext>
-	FmtContext::iterator format(nihil::ucl::string const &o,
-				    FmtContext& ctx) const
+	template <class FmtContext>
+	auto format(nihil::ucl::string const &o, FmtContext &ctx) const -> FmtContext::iterator
 	{
 		return base_formatter.format(o.value(), ctx);
 	}
diff --git a/nihil.ucl/tests/string.cc b/nihil.ucl/string.test.cc
index 6409b8d..68c57e8 100644
--- a/nihil.ucl/tests/string.cc
+++ b/nihil.ucl/string.test.cc
@@ -1,18 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <concepts>
-#include <list>
-#include <sstream>
-#include <string>
-#include <vector>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 #include <ucl.h>
 
+import nihil.std;
 import nihil.ucl;
 
+namespace {
 TEST_CASE("ucl: string: invariants", "[ucl]")
 {
 	using namespace nihil::ucl;
@@ -127,23 +121,23 @@ TEST_CASE("ucl: string: construct from UCL object", "[ucl]")
 	using namespace nihil::ucl;
 
 	SECTION("ref, correct type") {
-		auto uobj = ::ucl_object_fromstring("testing");
+		auto *uobj = ::ucl_object_fromstring("testing");
 
-		auto s = string(ref, uobj);
+		auto const s = string(ref, uobj);
 		REQUIRE(s == "testing");
 
 		::ucl_object_unref(uobj);
 	}
 
 	SECTION("noref, correct type") {
-		auto uobj = ::ucl_object_fromstring("testing");
+		auto *uobj = ::ucl_object_fromstring("testing");
 
-		auto s = string(noref, uobj);
+		auto const s = string(noref, uobj);
 		REQUIRE(s == "testing");
 	}
 
 	SECTION("ref, wrong type") {
-		auto uobj = ::ucl_object_frombool(true);
+		auto *uobj = ::ucl_object_frombool(true);
 
 		REQUIRE_THROWS_AS(string(ref, uobj), type_mismatch);
 
@@ -151,7 +145,7 @@ TEST_CASE("ucl: string: construct from UCL object", "[ucl]")
 	}
 
 	SECTION("noref, wrong type") {
-		auto uobj = ::ucl_object_frombool(true);
+		auto *uobj = ::ucl_object_frombool(true);
 
 		REQUIRE_THROWS_AS(string(noref, uobj), type_mismatch);
 
@@ -165,53 +159,53 @@ TEST_CASE("ucl: string: make_string", "[ucl]")
 	using namespace std::literals;
 
 	SECTION("empty string") {
-		auto str = make_string().value();
+		auto const str = make_string().value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "");
 	}
 
 	SECTION("from string literal") {
-		auto str = make_string("testing").value();
+		auto const str = make_string("testing").value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "testing");
 	}
 
 	SECTION("from std::string") {
-		auto str = make_string("testing"s).value();
+		auto const str = make_string("testing"s).value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "testing");
 	}
 
 	SECTION("from std::string_view") {
-		auto str = make_string("testing"sv).value();
+		auto const str = make_string("testing"sv).value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "testing");
 	}
 
 	SECTION("from contiguous range") {
-		auto s = std::vector{'t', 'e', 's', 't', 'i', 'n', 'g'};
-		auto str = make_string(s).value();
+		auto const s = std::vector{'t', 'e', 's', 't', 'i', 'n', 'g'};
+		auto const str = make_string(s).value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "testing");
 	}
 
 	SECTION("from non-contiguous range") {
-		auto s = std::list{'t', 'e', 's', 't', 'i', 'n', 'g'};
-		auto str = make_string(s).value();
+		auto const s = std::list{'t', 'e', 's', 't', 'i', 'n', 'g'};
+		auto const str = make_string(s).value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "testing");
 	}
 
 	SECTION("from contiguous iterator pair") {
-		auto s = std::vector{'t', 'e', 's', 't', 'i', 'n', 'g'};
-		auto str = make_string(s.begin(), s.end()).value();
+		auto const s = std::vector{'t', 'e', 's', 't', 'i', 'n', 'g'};
+		auto const str = make_string(s.begin(), s.end()).value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "testing");
 	}
 
 	SECTION("from non-contiguous iterator pair") {
-		auto s = std::list{'t', 'e', 's', 't', 'i', 'n', 'g'};
-		auto str = make_string(s.begin(), s.end()).value();
+		auto const s = std::list{'t', 'e', 's', 't', 'i', 'n', 'g'};
+		auto const str = make_string(s.begin(), s.end()).value();
 		REQUIRE(str.type() == object_type::string);
 		REQUIRE(str == "testing");
 	}
@@ -234,22 +228,19 @@ TEST_CASE("ucl: string: value()", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	auto s = string("te\"st");
-	REQUIRE(s.value() == "te\"st");
+	auto const s = string(R"(te"st)");
+	REQUIRE(s.value() == R"(te"st)");
 }
 
 TEST_CASE("ucl: string: key()", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	auto err = parse("a_string = \"test\"");
-	REQUIRE(err);
-
-	auto obj = *err;
-	REQUIRE(object_cast<string>(obj["a_string"])->key() == "a_string");
+	auto obj = parse(R"(a_string = "test")").value();
+	REQUIRE(object_cast<string>(obj["a_string"]).value().key() == "a_string");
 
-	auto s = string("test");
-	REQUIRE(s.key() == "");
+	auto const s = string("test");
+	REQUIRE(s.key().empty() == true);
 }
 
 TEST_CASE("ucl: string: size", "[ucl]")
@@ -280,7 +271,7 @@ TEST_CASE("ucl: string: iterate", "[ucl]")
 
 		auto end = str.end();
 		static_assert(std::sentinel_for<decltype(end),
-			      			decltype(begin)>);
+						      decltype(begin)>);
 
 		REQUIRE(*begin == 't');
 		++begin;
@@ -339,7 +330,7 @@ TEST_CASE("ucl: string: parse", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	auto obj = parse("value = \"te\\\"st\"").value();
+	auto obj = parse(R"(value = "te\"st")").value();
 
 	auto v = obj["value"];
 	REQUIRE(v.key() == "value");
@@ -350,7 +341,7 @@ TEST_CASE("ucl: string: emit", "[ucl]")
 {
 	using namespace nihil::ucl;
 
-	auto ucl = parse("str = \"te\\\"st\";").value();
+	auto ucl = parse(R"(str = "te\"st";)").value();
 
 	auto output = std::string();
 	emit(ucl, emitter::configuration, std::back_inserter(output));
@@ -371,7 +362,7 @@ TEST_CASE("ucl: string: format", "[ucl]")
 	}
 
 	SECTION("parsed string") {
-		auto obj = parse("string = \"te\\\"st\";").value();
+		auto obj = parse(R"(string = "te\"st";)").value();
 		auto s = object_cast<string>(obj["string"]).value();
 
 		auto str = std::format("{}", s);
@@ -399,7 +390,7 @@ TEST_CASE("ucl: string: print to ostream", "[ucl]")
 	}
 
 	SECTION("parsed string") {
-		auto obj = parse("string = \"te\\\"st\";").value();
+		auto obj = parse(R"(string = "te\"st";)").value();
 		auto s = object_cast<string>(obj["string"]).value();
 
 		auto strm = std::ostringstream();
@@ -413,3 +404,4 @@ TEST_CASE("ucl: string: print to ostream", "[ucl]")
 		REQUIRE(str == "     te\"st");
 	}
 }
+} // anonymous namespace
diff --git a/nihil.ucl/tests/CMakeLists.txt b/nihil.ucl/tests/CMakeLists.txt
deleted file mode 100644
index 13f30fa..0000000
--- a/nihil.ucl/tests/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-# This source code is released into the public domain.
-
-add_executable(nihil.ucl.test
-	emit.cc
-	parse.cc
-
-	object.cc
-	array.cc
-	boolean.cc
-	integer.cc
-	map.cc
-	real.cc
-	string.cc
-)
-
-target_link_libraries(nihil.ucl.test PRIVATE nihil.ucl Catch2::Catch2WithMain)
-
-include(CTest)
-include(Catch)
-catch_discover_tests(nihil.ucl.test)
diff --git a/nihil.ucl/type.cc b/nihil.ucl/type.cc
deleted file mode 100644
index 7d9cad7..0000000
--- a/nihil.ucl/type.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <format>
-
-module nihil.ucl;
-
-namespace nihil::ucl {
-
-auto str(object_type type) -> std::string_view {
-	using namespace std::literals;
-
-	switch (type) {
-	case object_type::object:
-		return "object"sv;
-	case object_type::array:
-		return "array"sv;
-	case object_type::integer:
-		return "integer"sv;
-	case object_type::real:
-		return "real"sv;
-	case object_type::string:
-		return "string"sv;
-	case object_type::boolean:
-		return "boolean"sv;
-	case object_type::time:
-		return "time"sv;
-	case object_type::userdata:
-		return "userdata"sv;
-	case object_type::null:
-		return "null"sv;
-	default:
-		// Don't fail here, since UCL might add more types that we
-		// don't know about.
-		return "unknown"sv;
-	}
-}
-
-type_mismatch::type_mismatch(object_type expected_type,
-			     object_type actual_type)
-	: error(std::format(
-		"expected type '{}' != actual type '{}'",
-		ucl::str(expected_type), ucl::str(actual_type)))
-	, m_expected_type(expected_type)
-	, m_actual_type(actual_type)
-{
-}
-
-auto type_mismatch::expected_type(this type_mismatch const &self) -> object_type
-{
-	return self.m_expected_type;
-}
-
-auto type_mismatch::actual_type(this type_mismatch const &self) -> object_type
-{
-	return self.m_actual_type;
-}
-	
-} // namespace nihil::ucl
diff --git a/nihil.ucl/type.ccm b/nihil.ucl/type.ccm
index f3b3aef..476546a 100644
--- a/nihil.ucl/type.ccm
+++ b/nihil.ucl/type.ccm
@@ -1,40 +1,61 @@
-/*
- * This source code is released into the public domain.
- */
-
+// This source code is released into the public domain.
 module;
 
-#include <concepts>
-#include <format>
-#include <stdexcept>
-#include <string>
-
 #include <ucl.h>
 
 export module nihil.ucl:type;
 
+import nihil.std;
 import nihil.error;
 
 namespace nihil::ucl {
 
 // Our strongly-typed version of ::ucl_type.
-export enum struct object_type {
-	object		= UCL_OBJECT,
-	array		= UCL_ARRAY,
-	integer		= UCL_INT,
-	real		= UCL_FLOAT,
-	string		= UCL_STRING,
-	boolean		= UCL_BOOLEAN,
-	time		= UCL_TIME,
-	userdata	= UCL_USERDATA,
-	null		= UCL_NULL,
+export enum struct object_type : std::uint8_t {
+	object = UCL_OBJECT,
+	array = UCL_ARRAY,
+	integer = UCL_INT,
+	real = UCL_FLOAT,
+	string = UCL_STRING,
+	boolean = UCL_BOOLEAN,
+	time = UCL_TIME,
+	userdata = UCL_USERDATA,
+	null = UCL_NULL,
 };
 
 // Get the name of a type.
-export auto str(object_type type) -> std::string_view;
+export auto str(object_type type) -> std::string_view
+{
+	using namespace std::literals;
+
+	switch (type) {
+	case object_type::object:
+		return "object"sv;
+	case object_type::array:
+		return "array"sv;
+	case object_type::integer:
+		return "integer"sv;
+	case object_type::real:
+		return "real"sv;
+	case object_type::string:
+		return "string"sv;
+	case object_type::boolean:
+		return "boolean"sv;
+	case object_type::time:
+		return "time"sv;
+	case object_type::userdata:
+		return "userdata"sv;
+	case object_type::null:
+		return "null"sv;
+	default:
+		// Don't fail here, since UCL might add more types that we
+		// don't know about.
+		return "unknown"sv;
+	}
+}
 
 // Concept of a UCL data type.
-export template<typename T>
+export template <typename T>
 concept datatype = requires(T o) {
 	{ o.get_ucl_object() } -> std::convertible_to<::ucl_object_t const *>;
 	{ o.type() } -> std::same_as<object_type>;
@@ -42,14 +63,28 @@ concept datatype = requires(T o) {
 };
 
 // Exception thrown when a type assertion fails.
-export struct type_mismatch : error {
-	type_mismatch(object_type expected_type, object_type actual_type);
+export struct type_mismatch : error
+{
+	type_mismatch(object_type expected_type, object_type actual_type)
+		: error(std::format("expected type '{}' != actual type '{}'",
+	                            ucl::str(expected_type), ucl::str(actual_type)))
+		, m_expected_type(expected_type)
+		, m_actual_type(actual_type)
+	{
+	}
 
 	// The type we expected.
-	auto expected_type(this type_mismatch const &self) -> object_type;
+	auto expected_type(this type_mismatch const &self) -> object_type
+	{
+		return self.m_expected_type;
+	}
+
 	// The type we got.
-	auto actual_type(this type_mismatch const &self) -> object_type;
-	
+	auto actual_type(this type_mismatch const &self) -> object_type
+	{
+		return self.m_actual_type;
+	}
+
 private:
 	object_type m_expected_type;
 	object_type m_actual_type;
diff --git a/nihil.util/CMakeLists.txt b/nihil.util/CMakeLists.txt
index 2ef916e..109e4d4 100644
--- a/nihil.util/CMakeLists.txt
+++ b/nihil.util/CMakeLists.txt
@@ -1,7 +1,12 @@
 # This source code is released into the public domain.
 
 add_library(nihil.util STATIC)
-target_link_libraries(nihil.util PRIVATE nihil.core nihil.error nihil.monad)
+target_link_libraries(nihil.util PRIVATE
+	nihil.std
+	nihil.core
+	nihil.error
+	nihil.monad
+)
 target_sources(nihil.util
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	nihil.util.ccm
@@ -10,6 +15,7 @@ target_sources(nihil.util
 	ctype.ccm
 	parse_size.ccm
 	next_word.ccm
+	save_errno.ccm
 	skipws.ccm
 	tabulate.ccm
 )
@@ -18,12 +24,12 @@ if(NIHIL_TESTS)
 	enable_testing()
 
 	add_executable(nihil.util.test
-		test_capture_stream.cc
-		test_ctype.cc
-		test_parse_size.cc
-		test_next_word.cc
-		test_skipws.cc
-		test_tabulate.cc
+		capture_stream.test.cc
+		ctype.test.cc
+		parse_size.test.cc
+		next_word.test.cc
+		skipws.test.cc
+		tabulate.test.cc
 	)
 	target_link_libraries(nihil.util.test PRIVATE
 		nihil.util
diff --git a/nihil.util/capture_stream.ccm b/nihil.util/capture_stream.ccm
index 7ec39a9..f061558 100644
--- a/nihil.util/capture_stream.ccm
+++ b/nihil.util/capture_stream.ccm
@@ -1,20 +1,13 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <iostream>
-
+// This source code is released into the public domain.
 export module nihil.util:capture_stream;
 
+import nihil.std;
+
 namespace nihil {
 
-/*
- * Capture output written to a stream and redirect it to an internal string
- * buffer.  Call .str() to get the data written.  Call .release() to stop
- * capturing (or simply delete the capture_stream object).
- */
+// Capture output written to a stream and redirect it to an internal string
+// buffer.  Call .str() to get the data written.  Call .release() to stop
+// capturing (or simply delete the capture_stream object).
 export template<typename Char, typename Traits>
 struct capture_stream {
 	capture_stream(std::basic_ostream<Char, Traits> &stream)
diff --git a/nihil.util/test_capture_stream.cc b/nihil.util/capture_stream.test.cc
index 27c8596..a4821b7 100644
--- a/nihil.util/test_capture_stream.cc
+++ b/nihil.util/capture_stream.test.cc
@@ -1,13 +1,11 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <iostream>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.util;
 
+namespace {
 TEST_CASE("nihil.util: capture", "[nihil][nihil.util]")
 {
 	SECTION("std::cout with release()") {
@@ -42,3 +40,5 @@ TEST_CASE("nihil.util: capture", "[nihil][nihil.util]")
 		REQUIRE(cap.str() == "1+1=2\n");
 	}
 }
+
+} // anonymous namespace
diff --git a/nihil.util/ctype.ccm b/nihil.util/ctype.ccm
index 6d30c4f..8f5de27 100644
--- a/nihil.util/ctype.ccm
+++ b/nihil.util/ctype.ccm
@@ -1,14 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <concepts>
-#include <locale>
-
+// This source code is released into the public domain.
 export module nihil.util:ctype;
 
+import nihil.std;
+
 namespace nihil {
 
 /*
@@ -21,15 +15,16 @@ namespace nihil {
  * ctype_is copies the locale, so passing a temporary is fine.
  */
 
-export struct ctype_is final {
-	ctype_is(std::ctype_base::mask mask_,
-		 std::locale const &locale_ = std::locale())
-	    : m_mask(mask_)
-	    , m_locale(locale_)
-	{}
+export struct ctype_is final
+{
+	explicit ctype_is(std::ctype_base::mask mask_,
+	                  std::locale const &locale_ = std::locale()) noexcept
+		: m_mask(mask_)
+		, m_locale(locale_)
+	{
+	}
 
-	[[nodiscard]] auto operator()(this ctype_is const &self,
-				      std::integral auto c)
+	[[nodiscard]] auto operator()(this ctype_is const &self, std::integral auto c)
 	{
 		using ctype = std::ctype<decltype(c)>;
 		auto &facet = std::use_facet<ctype>(self.m_locale);
@@ -37,11 +32,11 @@ export struct ctype_is final {
 	}
 
 private:
-	std::ctype_base::mask	m_mask;
-	std::locale		m_locale;
+	std::ctype_base::mask m_mask;
+	std::locale m_locale;
 };
 
-// Predefined tests for the current global locale. 
+// Predefined tests for the current global locale.
 
 export inline auto is_space = ctype_is(std::ctype_base::space);
 export inline auto is_print = ctype_is(std::ctype_base::print);
@@ -59,29 +54,19 @@ export inline auto is_graph = ctype_is(std::ctype_base::graph);
 // Predefined tests for the C locale.  The C locale is guaranteed to always be
 // available, so this doesn't create lifetime issues.
 
-export inline auto is_c_space =
-	ctype_is(std::ctype_base::space, std::locale::classic());
-export inline auto is_c_print =
-	ctype_is(std::ctype_base::print, std::locale::classic());
-export inline auto is_c_cntrl =
-	ctype_is(std::ctype_base::cntrl, std::locale::classic());
-export inline auto is_c_upper =
-	ctype_is(std::ctype_base::upper, std::locale::classic());
-export inline auto is_c_lower =
-	ctype_is(std::ctype_base::lower, std::locale::classic());
-export inline auto is_c_alpha =
-	ctype_is(std::ctype_base::alpha, std::locale::classic());
-export inline auto is_c_digit =
-	ctype_is(std::ctype_base::digit, std::locale::classic());
-export inline auto is_c_punct =
-	ctype_is(std::ctype_base::punct, std::locale::classic());
-export inline auto is_c_xdigit =
-	ctype_is(std::ctype_base::xdigit, std::locale::classic());
-export inline auto is_c_blank =
-	ctype_is(std::ctype_base::blank, std::locale::classic());
-export inline auto is_c_alnum =
-	ctype_is(std::ctype_base::alnum, std::locale::classic());
-export inline auto is_c_graph =
-	ctype_is(std::ctype_base::graph, std::locale::classic());
+//NOLINTBEGIN: Technically, std::locale::classic() can throw.  Assume it doesn't.
+export inline auto is_c_space = ctype_is(std::ctype_base::space, std::locale::classic());
+export inline auto is_c_print = ctype_is(std::ctype_base::print, std::locale::classic());
+export inline auto is_c_cntrl = ctype_is(std::ctype_base::cntrl, std::locale::classic());
+export inline auto is_c_upper = ctype_is(std::ctype_base::upper, std::locale::classic());
+export inline auto is_c_lower = ctype_is(std::ctype_base::lower, std::locale::classic());
+export inline auto is_c_alpha = ctype_is(std::ctype_base::alpha, std::locale::classic());
+export inline auto is_c_digit = ctype_is(std::ctype_base::digit, std::locale::classic());
+export inline auto is_c_punct = ctype_is(std::ctype_base::punct, std::locale::classic());
+export inline auto is_c_xdigit = ctype_is(std::ctype_base::xdigit, std::locale::classic());
+export inline auto is_c_blank = ctype_is(std::ctype_base::blank, std::locale::classic());
+export inline auto is_c_alnum = ctype_is(std::ctype_base::alnum, std::locale::classic());
+export inline auto is_c_graph = ctype_is(std::ctype_base::graph, std::locale::classic());
+//NOLINTEND
 
 } // namespace nihil
diff --git a/nihil.util/test_ctype.cc b/nihil.util/ctype.test.cc
index 62721d1..d000b45 100644
--- a/nihil.util/test_ctype.cc
+++ b/nihil.util/ctype.test.cc
@@ -1,11 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.util;
 
+namespace {
+
 TEST_CASE("ctype: space", "[ctype]") {
 	auto is_utf8_space =
 		nihil::ctype_is(std::ctype_base::space,
@@ -371,3 +372,5 @@ TEST_CASE("ctype: graph", "[ctype]") {
 	REQUIRE(nihil::is_c_graph(L'\u0430') == false);
 	REQUIRE(is_utf8_graph(L'\u0430') == true);
 }
+
+} // anonymous namespace
diff --git a/nihil.util/next_word.ccm b/nihil.util/next_word.ccm
index c5d3ad7..89eeaee 100644
--- a/nihil.util/next_word.ccm
+++ b/nihil.util/next_word.ccm
@@ -1,44 +1,27 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <algorithm>
-#include <locale>
-#include <ranges>
-#include <string>
-#include <utility>
-
+// This source code is released into the public domain.
 export module nihil.util:next_word;
 
 import :skipws;
 
 namespace nihil {
 
-/*
- * Return the next word from a string_view.  Skips leading whitespace, so
- * calling this repeatedly will return each word from the string.
- */
-
-export template<typename Char> [[nodiscard]]
-auto next_word(std::basic_string_view<Char> text,
-	       std::locale const &locale = std::locale())
-	-> std::pair<std::basic_string_view<Char>,
-		     std::basic_string_view<Char>>
+// Return the next word from a string_view.  Skips leading whitespace, so
+// calling this repeatedly will return each word from the string.
+export template <typename Char>
+[[nodiscard]]
+auto next_word(std::basic_string_view<Char> text, std::locale const &locale = std::locale())
+	-> std::pair<std::basic_string_view<Char>, std::basic_string_view<Char>>
 {
 	text = skipws(text, locale);
 
 	auto is_space = ctype_is(std::ctype_base::space, locale);
 	auto split_pos = std::ranges::find_if(text, is_space);
 
-	return {{std::ranges::begin(text), split_pos},
-		{split_pos, std::ranges::end(text)}};
+	return {{std::ranges::begin(text), split_pos}, {split_pos, std::ranges::end(text)}};
 }
 
-export template<typename Char>
-auto next_word(std::basic_string_view<Char> *text,
-	       std::locale const &locale = std::locale())
+export template <typename Char>
+auto next_word(std::basic_string_view<Char> *text, std::locale const &locale = std::locale())
 	-> std::basic_string_view<Char>
 {
 	auto [word, rest] = next_word(*text, locale);
diff --git a/nihil.util/test_next_word.cc b/nihil.util/next_word.test.cc
index 7e61237..87d491a 100644
--- a/nihil.util/test_next_word.cc
+++ b/nihil.util/next_word.test.cc
@@ -1,14 +1,12 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <locale>
-#include <string>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.util;
 
+namespace {
+
 TEST_CASE("next_word: basic", "[next_word]")
 {
 	using namespace std::literals;
@@ -63,3 +61,5 @@ TEST_CASE("next_word: locale", "[next_word]")
 	REQUIRE(words.first == L"foo");
 	REQUIRE(words.second == L"\u2003bar\u2003baz");
 }
+
+} // anonymous namespace
diff --git a/nihil.util/nihil.util.ccm b/nihil.util/nihil.util.ccm
index 89510c9..d8628a4 100644
--- a/nihil.util/nihil.util.ccm
+++ b/nihil.util/nihil.util.ccm
@@ -1,14 +1,10 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
+// This source code is released into the public domain.
 export module nihil.util;
 
 export import :capture_stream;
 export import :ctype;
 export import :parse_size;
 export import :next_word;
+export import :save_errno;
 export import :skipws;
 export import :tabulate;
diff --git a/nihil.util/parse_size.ccm b/nihil.util/parse_size.ccm
index c95ac50..7fc3fa4 100644
--- a/nihil.util/parse_size.ccm
+++ b/nihil.util/parse_size.ccm
@@ -1,20 +1,7 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <algorithm>
-#include <coroutine>
-#include <cstdint>
-#include <expected>
-#include <ranges>
-#include <string>
-#include <system_error>
-#include <utility>
-
+// This source code is released into the public domain.
 export module nihil.util:parse_size;
 
+import nihil.std;
 import nihil.core;
 import nihil.error;
 import nihil.monad;
@@ -23,53 +10,50 @@ import :ctype;
 
 namespace nihil {
 
-template<typename Char>
+export template <typename Char>
 auto get_multiplier(Char c) -> std::expected<std::uint64_t, error>
 {
 	auto ret = std::uint64_t{1};
 
+	// clang-format off
 	switch (c) {
-	case 'p': case 'P': ret *= 1024;	//NOLINT
-	case 't': case 'T': ret *= 1024;	//NOLINT
-	case 'g': case 'G': ret *= 1024;	//NOLINT
-	case 'm': case 'M': ret *= 1024;	//NOLINT
-	case 'k': case 'K': ret *= 1024;	//NOLINT
+	case 'p': case 'P': ret *= 1024;	// NOLINT
+	case 't': case 'T': ret *= 1024;	// NOLINT
+	case 'g': case 'G': ret *= 1024;	// NOLINT
+	case 'm': case 'M': ret *= 1024;	// NOLINT
+	case 'k': case 'K': ret *= 1024;	// NOLINT
 		return ret;
 
 	default:
-		return std::unexpected(error(errc::invalid_unit));
+		return error(errc::invalid_unit);
 	}
+	// clang-format on
 }
 
-/*
- * Parse a string containing a human-formatted size, such as "1024"
- * or "4g".  Parsing is always done in the "C" locale and does not
- * recognise thousands separators or negative numbers.
- */
-export template<typename T, typename Char> [[nodiscard]]
-auto parse_size(std::basic_string_view<Char> str)
-	-> std::expected<T, error>
+// Parse a string containing a human-formatted size, such as "1024"
+// or "4g".  Parsing is always done in the "C" locale and does not
+// recognise thousands separators or negative numbers.
+export template <typename T, typename Char>
+[[nodiscard]]
+auto parse_size(std::basic_string_view<Char> str) -> std::expected<T, error>
 {
 	// Extract the numeric part of the string.
 	auto it = std::ranges::find_if_not(str, is_c_digit);
-	auto num_str = std::basic_string_view<Char>(
-				std::ranges::begin(str), it);
+	auto num_str = std::basic_string_view<Char>(std::ranges::begin(str), it);
 
 	if (num_str.empty())
-		co_return std::unexpected(error(errc::empty_string));
+		co_return error(errc::empty_string);
 
 	auto ret = T{0};
 
 	for (auto c : num_str) {
 		if (ret > (std::numeric_limits<T>::max() / 10))
-			co_return std::unexpected(error(
-					std::errc::result_out_of_range));
+			co_return error(std::errc::result_out_of_range);
 		ret *= 10;
 
 		auto digit = static_cast<T>(c - '0');
 		if ((std::numeric_limits<T>::max() - digit) < ret)
-			co_return std::unexpected(error(
-					std::errc::result_out_of_range));
+			co_return error(std::errc::result_out_of_range);
 		ret += digit;
 	}
 
@@ -81,27 +65,26 @@ auto parse_size(std::basic_string_view<Char> str)
 
 	if (it != str.end())
 		// Multiplier is more than one character.
-		co_return std::unexpected(error(errc::invalid_unit));
+		co_return error(errc::invalid_unit);
 
 	auto mult = co_await get_multiplier(mchar);
 
 	if (std::cmp_greater(ret, std::numeric_limits<T>::max() / mult))
-		co_return std::unexpected(error(
-				std::errc::result_out_of_range));
+		co_return error(std::errc::result_out_of_range);
 
-	co_return ret * mult;
+	co_return ret *mult;
 }
 
-export template<typename T>
-[[nodiscard]] inline auto parse_size(char const *s)
+export template <typename T>
+[[nodiscard]] auto parse_size(char const *s)
 {
 	return parse_size<T>(std::string_view(s));
 }
 
-export template<typename T>
-[[nodiscard]] inline auto parse_size(wchar_t const *s)
+export template <typename T>
+[[nodiscard]] auto parse_size(wchar_t const *s)
 {
 	return parse_size<T>(std::wstring_view(s));
 }
 
-}
+} // namespace nihil
diff --git a/nihil.util/test_parse_size.cc b/nihil.util/parse_size.test.cc
index 692039b..d79912a 100644
--- a/nihil.util/test_parse_size.cc
+++ b/nihil.util/parse_size.test.cc
@@ -1,12 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <cstdint>
-#include <system_error>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.core;
 import nihil.error;
 import nihil.util;
diff --git a/nihil.util/save_errno.ccm b/nihil.util/save_errno.ccm
new file mode 100644
index 0000000..27567f8
--- /dev/null
+++ b/nihil.util/save_errno.ccm
@@ -0,0 +1,35 @@
+// This source code is released into the public domain.
+module;
+
+#include <cerrno>
+
+export module nihil.util:save_errno;
+
+// save_errno: save the current value of errno and restore it when we're destroyed.
+// this allows wrappers around C functions that use errno to preserve the caller's
+// errno value.
+
+namespace nihil {
+
+export struct save_errno final
+{
+	save_errno() : m_errno(errno) {}
+
+	~save_errno()
+	{
+		errno = m_errno;
+	}
+
+	// Not copyable
+	save_errno(const save_errno&) = delete;
+	auto operator=(const save_errno&) -> save_errno & = delete;
+
+	// Not movable
+	save_errno(save_errno&&) = delete;
+	auto operator=(save_errno&&) -> save_errno & = delete;
+
+private:
+	int	m_errno;
+};
+
+} // namespace nihil
diff --git a/nihil.util/skipws.ccm b/nihil.util/skipws.ccm
index 4813ae8..0a15775 100644
--- a/nihil.util/skipws.ccm
+++ b/nihil.util/skipws.ccm
@@ -1,27 +1,14 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <algorithm>
-#include <locale>
-#include <ranges>
-#include <string>
-
+// This source code is released into the public domain.
 export module nihil.util:skipws;
 
 import :ctype;
 
 namespace nihil {
 
-/*
- * Remove leading whitespace from a string.
- */
-
-export template<typename Char> [[nodiscard]]
-auto skipws(std::basic_string_view<Char> text,
-	    std::locale const &locale = std::locale())
+// Remove leading whitespace from a string.
+export template <typename Char>
+[[nodiscard]]
+auto skipws(std::basic_string_view<Char> text, std::locale const &locale = std::locale())
 	-> std::basic_string_view<Char>
 {
 	auto is_space = ctype_is(std::ctype_base::space, locale);
@@ -29,10 +16,8 @@ auto skipws(std::basic_string_view<Char> text,
 	return {nonws, std::ranges::end(text)};
 }
 
-export template<typename Char>
-auto skipws(std::basic_string_view<Char> *text,
-	    std::locale const &locale = std::locale())
-	-> void
+export template <typename Char>
+auto skipws(std::basic_string_view<Char> *text, std::locale const &locale = std::locale()) -> void
 {
 	*text = skipws(*text, locale);
 }
diff --git a/nihil.util/test_skipws.cc b/nihil.util/skipws.test.cc
index 837c1f3..0cb741c 100644
--- a/nihil.util/test_skipws.cc
+++ b/nihil.util/skipws.test.cc
@@ -1,17 +1,14 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <locale>
-#include <string>
-using namespace std::literals;
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.util;
 
 TEST_CASE("skipws: basic", "[skipws]")
 {
+	using namespace std::literals;
+
 	REQUIRE(nihil::skipws("foo"sv) == "foo");
 	REQUIRE(nihil::skipws("   foo"sv) == "foo");
 	REQUIRE(nihil::skipws("foo "sv) == "foo ");
@@ -20,6 +17,8 @@ TEST_CASE("skipws: basic", "[skipws]")
 
 TEST_CASE("skipws: pointer", "[skipws]")
 {
+	using namespace std::literals;
+
 	auto s = "foo"sv;
 	nihil::skipws(&s);
 	REQUIRE(s == "foo");
@@ -39,6 +38,8 @@ TEST_CASE("skipws: pointer", "[skipws]")
 
 TEST_CASE("skipws: locale", "[skipws]")
 {
+	using namespace std::literals;
+
 	// Assume the default locale is C.
 	REQUIRE(nihil::skipws(L"\u2003foo"sv) == L"\u2003foo");
 	REQUIRE(nihil::skipws(L"\u2003foo"sv, std::locale("C.UTF-8")) == L"foo");
diff --git a/nihil.util/tabulate.ccm b/nihil.util/tabulate.ccm
index 5998b24..8f5c22e 100644
--- a/nihil.util/tabulate.ccm
+++ b/nihil.util/tabulate.ccm
@@ -1,53 +1,38 @@
-/*
- * This source code is released into the public domain.
- */
-
-module;
-
-#include <algorithm>
-#include <cstdlib>
-#include <format>
-#include <ranges>
-#include <iterator>
-#include <vector>
-
+// This source code is released into the public domain.
 export module nihil.util:tabulate;
 
+import nihil.std;
 import nihil.error;
 import :ctype;
 
 namespace nihil {
 
-/*
- * tabulate: format the given range in an ASCII table and write the output
- * to the given output iterator.  The range's values will be converted to
- * strings as if by std::format.
- *
- * tabulate is implemented by copying the range; this allows it to work on
- * input/forward ranges at the cost of slightly increased memory use.
- *
- * The table spec is a string consisting of zero or more field formats,
- * formatted as {flags:fieldname}; both flags and fieldname are optional.
- * If there are fewer field formats than fields, the remaining fields
- * are formatted as if by {:}.
- *
- * The following flags are supported:
- *
- * 	<	left-align this column (default)
- * 	>	right-align this column
- */
+// tabulate: format the given range in an ASCII table and write the output
+// to the given output iterator.  The range's values will be converted to
+// strings as if by std::format.
+//
+// tabulate is implemented by copying the range; this allows it to work on
+// input/forward ranges at the cost of slightly increased memory use.
+//
+// The table spec is a string consisting of zero or more field formats,
+// formatted as {flags:fieldname}; both flags and fieldname are optional.
+// If there are fewer field formats than fields, the remaining fields
+// are formatted as if by {:}.
+//
+// The following flags are supported:
+//
+// 	<	left-align this column (default)
+// 	>	right-align this column
 
 // Exception thrown when a table spec is invalid.
 export struct table_spec_error : error {
-	table_spec_error(std::string_view what)
+	explicit table_spec_error(std::string_view what)
 		: error(what)
 	{
 	}
 };
 
-/*
- * The specification for a single field.
- */
+// The specification for a single field.
 template<typename Char>
 struct field_spec {
 	enum align_t { left, right };
diff --git a/nihil.util/test_tabulate.cc b/nihil.util/tabulate.test.cc
index 8dee796..408cc18 100644
--- a/nihil.util/test_tabulate.cc
+++ b/nihil.util/tabulate.test.cc
@@ -1,13 +1,8 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <iterator>
-#include <string>
-#include <vector>
+// This source code is released into the public domain.
 
 #include <catch2/catch_test_macros.hpp>
 
+import nihil.std;
 import nihil.util;
 
 using namespace std::literals;
diff --git a/nihil.uuid/CMakeLists.txt b/nihil.uuid/CMakeLists.txt
index f82d308..a210322 100644
--- a/nihil.uuid/CMakeLists.txt
+++ b/nihil.uuid/CMakeLists.txt
@@ -1,6 +1,7 @@
 # This source code is released into the public domain.
 
 add_library(nihil.uuid STATIC)
+target_link_libraries(nihil.uuid PRIVATE nihil.std)
 target_sources(nihil.uuid
 	PUBLIC FILE_SET modules TYPE CXX_MODULES FILES
 	uuid.ccm
diff --git a/nihil.uuid/test.cc b/nihil.uuid/test.cc
index 0f21298..551c491 100644
--- a/nihil.uuid/test.cc
+++ b/nihil.uuid/test.cc
@@ -2,17 +2,17 @@
  * From https://github.com/mariusbancila/stduuid
  *
  * Copyright (c) 2017
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
  * deal in the Software without restriction, including without limitation the
  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  * sell copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -22,45 +22,35 @@
  * IN THE SOFTWARE.
  */
 
-#include <algorithm>
-#include <random>
-#include <set>
-#include <unordered_set>
-
 #include <catch2/catch_test_macros.hpp>
 
-//NOLINTBEGIN(bugprone-unchecked-optional-access)
+import nihil.std;
+import nihil.uuid;
 
-namespace
-{
+// NOLINTBEGIN(bugprone-unchecked-optional-access)
 
+namespace {
 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0205r0.html
 template <typename EngineT, std::size_t StateSize = EngineT::state_size>
-void seed_rng(EngineT& engine)
+void seed_rng(EngineT &engine)
 {
 	using engine_type = typename EngineT::result_type;
 	using device_type = std::random_device::result_type;
 	using seedseq_type = std::seed_seq::result_type;
 
 	constexpr auto bytes_needed = StateSize * sizeof(engine_type);
-	constexpr auto numbers_needed =
-		(sizeof(device_type) < sizeof(seedseq_type))
-		? (bytes_needed / sizeof(device_type))
-		: (bytes_needed / sizeof(seedseq_type));
+	constexpr auto numbers_needed = (sizeof(device_type) < sizeof(seedseq_type))
+					      ? (bytes_needed / sizeof(device_type))
+					      : (bytes_needed / sizeof(seedseq_type));
 
 	auto numbers = std::array<device_type, numbers_needed>{};
 	auto rnddev = std::random_device{};
 	std::ranges::generate(numbers, std::ref(rnddev));
 
-	auto seedseq = std::seed_seq(std::cbegin(numbers),
-				     std::cend(numbers));
+	auto seedseq = std::seed_seq(std::cbegin(numbers), std::cend(numbers));
 	engine.seed(seedseq);
 }
 
-} // anonymous namespace
-
-import nihil.uuid;
-
 using namespace nihil;
 
 TEST_CASE("uuid: Test multiple default generators", "[uuid]")
@@ -70,12 +60,12 @@ TEST_CASE("uuid: Test multiple default generators", "[uuid]")
 
 	{
 		std::random_device rd;
-		auto seed_data = std::array<int, std::mt19937::state_size> {};
+		auto               seed_data = std::array<int, std::mt19937::state_size>{};
 		std::ranges::generate(seed_data, std::ref(rd));
 		std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-		std::mt19937 generator(seq);
+		std::mt19937  generator(seq);
 
-		id1 = uuid_random_generator{ generator }();
+		id1 = uuid_random_generator{generator}();
 		REQUIRE(!id1.is_nil());
 		REQUIRE(id1.version() == uuid_version::random_number_based);
 		REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -83,12 +73,12 @@ TEST_CASE("uuid: Test multiple default generators", "[uuid]")
 
 	{
 		std::random_device rd;
-		auto seed_data = std::array<int, std::mt19937::state_size> {};
+		auto               seed_data = std::array<int, std::mt19937::state_size>{};
 		std::ranges::generate(seed_data, std::ref(rd));
 		std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-		std::mt19937 generator(seq);
+		std::mt19937  generator(seq);
 
-		id2 = uuid_random_generator{ generator }();
+		id2 = uuid_random_generator{generator}();
 		REQUIRE(!id2.is_nil());
 		REQUIRE(id2.version() == uuid_version::random_number_based);
 		REQUIRE(id2.variant() == uuid_variant::rfc);
@@ -100,10 +90,10 @@ TEST_CASE("uuid: Test multiple default generators", "[uuid]")
 TEST_CASE("uuid: Test default generator", "[uuid]")
 {
 	std::random_device rd;
-	auto seed_data = std::array<int, std::mt19937::state_size> {};
+	auto               seed_data = std::array<int, std::mt19937::state_size>{};
 	std::ranges::generate(seed_data, std::ref(rd));
 	std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-	std::mt19937 generator(seq);
+	std::mt19937  generator(seq);
 
 	uuid const guid = uuid_random_generator{generator}();
 	REQUIRE(!guid.is_nil());
@@ -111,17 +101,16 @@ TEST_CASE("uuid: Test default generator", "[uuid]")
 	REQUIRE(guid.variant() == uuid_variant::rfc);
 }
 
-TEST_CASE("uuid: Test random generator (conversion ctor w/ smart ptr)",
-	  "[uuid]")
+TEST_CASE("uuid: Test random generator (conversion ctor w/ smart ptr)", "[uuid]")
 {
 	std::random_device rd;
-	auto seed_data = std::array<int, std::mt19937::state_size> {};
+	auto               seed_data = std::array<int, std::mt19937::state_size>{};
 	std::ranges::generate(seed_data, std::ref(rd));
 	std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-	std::mt19937 generator(seq);
+	std::mt19937  generator(seq);
 
 	uuid_random_generator dgen(&generator);
-	auto id1 = dgen();
+	auto                  id1 = dgen();
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::random_number_based);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -137,13 +126,13 @@ TEST_CASE("uuid: Test random generator (conversion ctor w/ smart ptr)",
 TEST_CASE("uuid: Test random generator (conversion ctor w/ ptr)", "[uuid]")
 {
 	std::random_device rd;
-	auto seed_data = std::array<int, std::mt19937::state_size> {};
+	auto               seed_data = std::array<int, std::mt19937::state_size>{};
 	std::ranges::generate(seed_data, std::ref(rd));
 	std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-	auto generator = std::make_unique<std::mt19937>(seq);
+	auto          generator = std::make_unique<std::mt19937>(seq);
 
 	uuid_random_generator dgen(generator.get());
-	auto id1 = dgen();
+	auto                  id1 = dgen();
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::random_number_based);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -159,13 +148,13 @@ TEST_CASE("uuid: Test random generator (conversion ctor w/ ptr)", "[uuid]")
 TEST_CASE("uuid: Test random generator (conversion ctor w/ ref)", "[uuid]")
 {
 	std::random_device rd;
-	auto seed_data = std::array<int, std::mt19937::state_size> {};
+	auto               seed_data = std::array<int, std::mt19937::state_size>{};
 	std::ranges::generate(seed_data, std::ref(rd));
 	std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-	std::mt19937 generator(seq);
+	std::mt19937  generator(seq);
 
 	uuid_random_generator dgen(generator);
-	auto id1 = dgen();
+	auto                  id1 = dgen();
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::random_number_based);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -179,16 +168,17 @@ TEST_CASE("uuid: Test random generator (conversion ctor w/ ref)", "[uuid]")
 }
 
 TEST_CASE("uuid: Test basic random generator (conversion ctor w/ ptr) "
-	  "w/ ranlux48_base", "[uuid]")
+	  "w/ ranlux48_base",
+	  "[uuid]")
 {
 	std::random_device rd;
-	auto seed_data = std::array<int, 6> {};
+	auto               seed_data = std::array<int, 6>{};
 	std::ranges::generate(seed_data, std::ref(rd));
-	std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
+	std::seed_seq      seq(std::begin(seed_data), std::end(seed_data));
 	std::ranlux48_base generator(seq);
 
 	basic_uuid_random_generator<std::ranlux48_base> dgen(&generator);
-	auto id1 = dgen();
+	auto                                            id1 = dgen();
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::random_number_based);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -202,16 +192,17 @@ TEST_CASE("uuid: Test basic random generator (conversion ctor w/ ptr) "
 }
 
 TEST_CASE("uuid: Test basic random generator (conversion ctor w/ smart ptr) "
-	  "w/ ranlux48_base", "[uuid]")
+	  "w/ ranlux48_base",
+	  "[uuid]")
 {
 	std::random_device rd;
-	auto seed_data = std::array<int, 6> {};
+	auto               seed_data = std::array<int, 6>{};
 	std::ranges::generate(seed_data, std::ref(rd));
 	std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-	auto generator = std::make_unique<std::ranlux48_base>(seq);
+	auto          generator = std::make_unique<std::ranlux48_base>(seq);
 
 	basic_uuid_random_generator<std::ranlux48_base> dgen(generator.get());
-	auto id1 = dgen();
+	auto                                            id1 = dgen();
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::random_number_based);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -225,16 +216,17 @@ TEST_CASE("uuid: Test basic random generator (conversion ctor w/ smart ptr) "
 }
 
 TEST_CASE("uuid: Test basic random generator (conversion ctor w/ ref) "
-	  "w/ ranlux48_base", "[uuid]")
+	  "w/ ranlux48_base",
+	  "[uuid]")
 {
 	std::random_device rd;
-	auto seed_data = std::array<int, 6> {};
+	auto               seed_data = std::array<int, 6>{};
 	std::ranges::generate(seed_data, std::ref(rd));
-	std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
+	std::seed_seq      seq(std::begin(seed_data), std::end(seed_data));
 	std::ranlux48_base generator(seq);
 
 	basic_uuid_random_generator<std::ranlux48_base> dgen(generator);
-	auto id1 = dgen();
+	auto                                            id1 = dgen();
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::random_number_based);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -289,7 +281,7 @@ TEST_CASE("uuid: Test name generator (std::string)", "[uuid]")
 	using namespace std::string_literals;
 
 	uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value());
-	auto id1 = dgen("john"s);
+	auto                id1 = dgen("john"s);
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::name_based_sha1);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -319,7 +311,7 @@ TEST_CASE("uuid: Test name generator (std::string_view)", "[uuid]")
 	using namespace std::string_view_literals;
 
 	uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value());
-	auto id1 = dgen("john"sv);
+	auto                id1 = dgen("john"sv);
 	REQUIRE(!id1.is_nil());
 	REQUIRE(id1.version() == uuid_version::name_based_sha1);
 	REQUIRE(id1.variant() == uuid_variant::rfc);
@@ -345,12 +337,13 @@ TEST_CASE("uuid: Test name generator (std::string_view)", "[uuid]")
 }
 
 TEST_CASE("uuid: Test name generator equality (char const*, std::string, "
-	  "std::string_view)", "[uuid]")
+	  "std::string_view)",
+	  "[uuid]")
 {
 	using namespace std::literals;
 
-	auto dgen = uuid_name_generator(uuid::from_string(
-			"47183823-2574-4bfd-b411-99ed177d3e43").value());
+	auto dgen = uuid_name_generator(
+		uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value());
 	auto id1 = dgen("john");
 	auto id2 = dgen("john"s);
 	auto id3 = dgen("john"sv);
@@ -368,30 +361,20 @@ TEST_CASE("uuid: Test default constructor", "[uuid]")
 TEST_CASE("uuid: Test string conversion", "[uuid]")
 {
 	auto empty = uuid();
-	REQUIRE(to_string(empty) ==
-		"00000000-0000-0000-0000-000000000000");
-	REQUIRE(to_string<wchar_t>(empty) ==
-		L"00000000-0000-0000-0000-000000000000");
+	REQUIRE(to_string(empty) == "00000000-0000-0000-0000-000000000000");
+	REQUIRE(to_string<wchar_t>(empty) == L"00000000-0000-0000-0000-000000000000");
 }
 
 TEST_CASE("uuid: Test is_valid_uuid(char*)", "[uuid]")
 {
-	REQUIRE(uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e43"));
-	REQUIRE(uuid::is_valid_uuid(
-			"{47183823-2574-4bfd-b411-99ed177d3e43}"));
-	REQUIRE(uuid::is_valid_uuid(
-			L"47183823-2574-4bfd-b411-99ed177d3e43"));
-	REQUIRE(uuid::is_valid_uuid(
-			L"{47183823-2574-4bfd-b411-99ed177d3e43}"));
-	REQUIRE(uuid::is_valid_uuid(
-			"00000000-0000-0000-0000-000000000000"));
-	REQUIRE(uuid::is_valid_uuid(
-			"{00000000-0000-0000-0000-000000000000}"));
-	REQUIRE(uuid::is_valid_uuid(
-			L"00000000-0000-0000-0000-000000000000"));
-	REQUIRE(uuid::is_valid_uuid(
-			L"{00000000-0000-0000-0000-000000000000}"));
+	REQUIRE(uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43"));
+	REQUIRE(uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43}"));
+	REQUIRE(uuid::is_valid_uuid(L"47183823-2574-4bfd-b411-99ed177d3e43"));
+	REQUIRE(uuid::is_valid_uuid(L"{47183823-2574-4bfd-b411-99ed177d3e43}"));
+	REQUIRE(uuid::is_valid_uuid("00000000-0000-0000-0000-000000000000"));
+	REQUIRE(uuid::is_valid_uuid("{00000000-0000-0000-0000-000000000000}"));
+	REQUIRE(uuid::is_valid_uuid(L"00000000-0000-0000-0000-000000000000"));
+	REQUIRE(uuid::is_valid_uuid(L"{00000000-0000-0000-0000-000000000000}"));
 }
 
 TEST_CASE("uuid: Test is_valid_uuid(basic_string)", "[uuid]")
@@ -443,36 +426,24 @@ TEST_CASE("uuid: Test is_valid_uuid(basic_string_view)", "[uuid]")
 {
 	using namespace std::string_view_literals;
 
-	REQUIRE(uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e43"sv));
-	REQUIRE(uuid::is_valid_uuid(
-			"{47183823-2574-4bfd-b411-99ed177d3e43}"sv));
-	REQUIRE(uuid::is_valid_uuid(
-			L"47183823-2574-4bfd-b411-99ed177d3e43"sv));
-	REQUIRE(uuid::is_valid_uuid(
-			L"{47183823-2574-4bfd-b411-99ed177d3e43}"sv));
-	REQUIRE(uuid::is_valid_uuid(
-			"00000000-0000-0000-0000-000000000000"sv));
-	REQUIRE(uuid::is_valid_uuid(
-			"{00000000-0000-0000-0000-000000000000}"sv));
-	REQUIRE(uuid::is_valid_uuid(
-			L"00000000-0000-0000-0000-000000000000"sv));
-	REQUIRE(uuid::is_valid_uuid(
-			L"{00000000-0000-0000-0000-000000000000}"sv));
+	REQUIRE(uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43"sv));
+	REQUIRE(uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43}"sv));
+	REQUIRE(uuid::is_valid_uuid(L"47183823-2574-4bfd-b411-99ed177d3e43"sv));
+	REQUIRE(uuid::is_valid_uuid(L"{47183823-2574-4bfd-b411-99ed177d3e43}"sv));
+	REQUIRE(uuid::is_valid_uuid("00000000-0000-0000-0000-000000000000"sv));
+	REQUIRE(uuid::is_valid_uuid("{00000000-0000-0000-0000-000000000000}"sv));
+	REQUIRE(uuid::is_valid_uuid(L"00000000-0000-0000-0000-000000000000"sv));
+	REQUIRE(uuid::is_valid_uuid(L"{00000000-0000-0000-0000-000000000000}"sv));
 }
 
 TEST_CASE("uuid: Test is_valid_uuid(char*) invalid format", "[uuid]")
 {
 	REQUIRE(!uuid::is_valid_uuid(""));
 	REQUIRE(!uuid::is_valid_uuid("{}"));
-	REQUIRE(!uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e4"));
-	REQUIRE(!uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e430"));
-	REQUIRE(!uuid::is_valid_uuid(
-			"{47183823-2574-4bfd-b411-99ed177d3e43"));
-	REQUIRE(!uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e43}"));
+	REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e4"));
+	REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e430"));
+	REQUIRE(!uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43"));
+	REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43}"));
 }
 
 TEST_CASE("uuid: Test is_valid_uuid(basic_string) invalid format", "[uuid]")
@@ -510,21 +481,16 @@ TEST_CASE("uuid: Test is_valid_uuid(basic_string) invalid format", "[uuid]")
 	}
 }
 
-TEST_CASE("uuid: Test is_valid_uuid(basic_string_view) invalid format",
-	  "[uuid]")
+TEST_CASE("uuid: Test is_valid_uuid(basic_string_view) invalid format", "[uuid]")
 {
 	using namespace std::string_view_literals;
 
 	REQUIRE(!uuid::is_valid_uuid(""sv));
 	REQUIRE(!uuid::is_valid_uuid("{}"sv));
-	REQUIRE(!uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e4"sv));
-	REQUIRE(!uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e430"sv));
-	REQUIRE(!uuid::is_valid_uuid(
-			"{47183823-2574-4bfd-b411-99ed177d3e43"sv));
-	REQUIRE(!uuid::is_valid_uuid(
-			"47183823-2574-4bfd-b411-99ed177d3e43}"sv));
+	REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e4"sv));
+	REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e430"sv));
+	REQUIRE(!uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43"sv));
+	REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43}"sv));
 }
 
 TEST_CASE("uuid: Test from_string(char*)", "[uuid]")
@@ -714,14 +680,10 @@ TEST_CASE("uuid: Test from_string(char*) invalid format", "[uuid]")
 {
 	REQUIRE(!uuid::from_string("").has_value());
 	REQUIRE(!uuid::from_string("{}").has_value());
-	REQUIRE(!uuid::from_string(
-			"47183823-2574-4bfd-b411-99ed177d3e4").has_value());
-	REQUIRE(!uuid::from_string(
-			"47183823-2574-4bfd-b411-99ed177d3e430").has_value());
-	REQUIRE(!uuid::from_string(
-			"{47183823-2574-4bfd-b411-99ed177d3e43").has_value());
-	REQUIRE(!uuid::from_string(
-			"47183823-2574-4bfd-b411-99ed177d3e43}").has_value());
+	REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e4").has_value());
+	REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e430").has_value());
+	REQUIRE(!uuid::from_string("{47183823-2574-4bfd-b411-99ed177d3e43").has_value());
+	REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43}").has_value());
 }
 
 TEST_CASE("uuid: Test from_string(basic_string) invalid format", "[uuid]")
@@ -765,14 +727,10 @@ TEST_CASE("uuid: Test from_string(basic_string_view) invalid format", "[uuid]")
 
 	REQUIRE(!uuid::from_string(""sv).has_value());
 	REQUIRE(!uuid::from_string("{}"sv).has_value());
-	REQUIRE(!uuid::from_string(
-			"47183823-2574-4bfd-b411-99ed177d3e4"sv).has_value());
-	REQUIRE(!uuid::from_string(
-			"47183823-2574-4bfd-b411-99ed177d3e430"sv).has_value());
-	REQUIRE(!uuid::from_string(
-			"{47183823-2574-4bfd-b411-99ed177d3e43"sv).has_value());
-	REQUIRE(!uuid::from_string(
-			"47183823-2574-4bfd-b411-99ed177d3e43}"sv).has_value());
+	REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e4"sv).has_value());
+	REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e430"sv).has_value());
+	REQUIRE(!uuid::from_string("{47183823-2574-4bfd-b411-99ed177d3e43"sv).has_value());
+	REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43}"sv).has_value());
 }
 
 TEST_CASE("uuid: Test iterators constructor", "[uuid]")
@@ -780,31 +738,22 @@ TEST_CASE("uuid: Test iterators constructor", "[uuid]")
 	using namespace std::string_literals;
 
 	{
-		std::array<uuid::value_type, 16> arr{{
-			0x47, 0x18, 0x38, 0x23,
-			0x25, 0x74,
-			0x4b, 0xfd,
-			0xb4, 0x11,
-			0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43
-		}};
+		std::array<uuid::value_type, 16> arr{
+				{0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed,
+				 0x17, 0x7d, 0x3e, 0x43}
+		};
 
-		uuid guid(std::begin(arr), std::end(arr));
-		REQUIRE(to_string(guid) ==
-			"47183823-2574-4bfd-b411-99ed177d3e43"s);
+		auto const guid = uuid(std::begin(arr), std::end(arr));
+		REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s);
 	}
 
 	{
-		uuid::value_type arr[16] = { // NOLINT
-			0x47, 0x18, 0x38, 0x23,
-			0x25, 0x74,
-			0x4b, 0xfd,
-			0xb4, 0x11,
-			0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43
-		};
+		uuid::value_type arr[16] = {// NOLINT
+			0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd,
+			0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43};
 
-		uuid guid(std::begin(arr), std::end(arr));
-		REQUIRE(to_string(guid) ==
-			"47183823-2574-4bfd-b411-99ed177d3e43"s);
+		auto const guid = uuid(std::begin(arr), std::end(arr));
+		REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s);
 	}
 }
 
@@ -813,44 +762,31 @@ TEST_CASE("uuid: Test array constructors", "[uuid]")
 	using namespace std::string_literals;
 
 	{
-		uuid guid{{
-			0x47, 0x18, 0x38, 0x23,
-			0x25, 0x74,
-			0x4b, 0xfd,
-			0xb4, 0x11,
-			0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43
-		}};
+		auto const guid = uuid {
+				{0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed,
+				 0x17, 0x7d, 0x3e, 0x43}
+		};
 
-		REQUIRE(to_string(guid) ==
-			"47183823-2574-4bfd-b411-99ed177d3e43"s);
+		REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s);
 	}
 
 	{
-		std::array<uuid::value_type, 16> arr{{
-			0x47, 0x18, 0x38, 0x23,
-			0x25, 0x74,
-			0x4b, 0xfd,
-			0xb4, 0x11,
-			0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43
-		}};
+		auto arr = std::array<uuid::value_type, 16>{
+				{0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed,
+				 0x17, 0x7d, 0x3e, 0x43}
+		};
 
-		uuid guid(arr);
-		REQUIRE(to_string(guid) ==
-			"47183823-2574-4bfd-b411-99ed177d3e43"s);
+		auto const guid = uuid(arr);
+		REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s);
 	}
 
 	{
-		uuid::value_type arr[16] { //NOLINT
-			0x47, 0x18, 0x38, 0x23,
-			0x25, 0x74,
-			0x4b, 0xfd,
-			0xb4, 0x11,
-			0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43
-		};
+		uuid::value_type arr[16]{// NOLINT
+			0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd,
+			0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43};
 
-		uuid guid(arr);
-		REQUIRE(to_string(guid) ==
-			"47183823-2574-4bfd-b411-99ed177d3e43"s);
+		auto const guid = uuid(arr);
+		REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s);
 	}
 }
 
@@ -874,21 +810,15 @@ TEST_CASE("Test comparison", "[uuid]")
 	auto engine = uuid_random_generator::engine_type{};
 	seed_rng(engine);
 
-	uuid_random_generator gen{engine};
+	auto gen = uuid_random_generator{engine};
 	auto id = gen();
 
 	REQUIRE(empty < id);
 
-	std::set<uuid> ids{
-		uuid{},
-		gen(),
-		gen(),
-		gen(),
-		gen()
-	};
+	auto ids = std::set{uuid{}, gen(), gen(), gen(), gen()};
 
 	REQUIRE(ids.size() == 5);
-	REQUIRE(ids.find(uuid{}) != ids.end());
+	REQUIRE(ids.contains(uuid{}) == true);
 }
 
 TEST_CASE("uuid: Test hashing", "[uuid]")
@@ -904,15 +834,9 @@ TEST_CASE("uuid: Test hashing", "[uuid]")
 
 	auto engine = uuid_random_generator::engine_type{};
 	seed_rng(engine);
-	uuid_random_generator gen{ engine };
-
-	std::unordered_set<uuid> ids{
-		uuid{},
-		gen(),
-		gen(),
-		gen(),
-		gen()
-	};
+	uuid_random_generator gen{engine};
+
+	std::unordered_set<uuid> ids{uuid{}, gen(), gen(), gen(), gen()};
 
 	REQUIRE(ids.size() == 5);
 	REQUIRE(ids.find(uuid{}) != ids.end());
@@ -950,7 +874,7 @@ TEST_CASE("uuid: Test constexpr", "[uuid]")
 
 TEST_CASE("uuid: Test size", "[uuid]")
 {
-   REQUIRE(sizeof(uuid) == 16);
+	REQUIRE(sizeof(uuid) == 16);
 }
 
 TEST_CASE("uuid: Test assignment", "[uuid]")
@@ -973,16 +897,13 @@ TEST_CASE("uuid: Test trivial", "[uuid]")
 
 TEST_CASE("uuid: Test as_bytes", "[uuid]")
 {
-	std::array<uuid::value_type, 16> arr{{
-		0x47, 0x18, 0x38, 0x23,
-		0x25, 0x74,
-		0x4b, 0xfd,
-		0xb4, 0x11,
-		0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43
-	}};
+	std::array<uuid::value_type, 16> arr{
+			{0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d,
+			 0x3e, 0x43}
+	};
 
 	{
-		uuid id{ arr };
+		uuid id{arr};
 		REQUIRE(!id.is_nil());
 
 		auto view = id.as_bytes();
@@ -990,12 +911,13 @@ TEST_CASE("uuid: Test as_bytes", "[uuid]")
 	}
 
 	{
-		const uuid id{ arr };
+		const uuid id{arr};
 		REQUIRE(!id.is_nil());
 
 		auto view = id.as_bytes();
 		REQUIRE(memcmp(view.data(), arr.data(), arr.size()) == 0);
 	}
 }
+} // anonymous namespace
 
-//NOLINTEND(bugprone-unchecked-optional-access)
+// NOLINTEND(bugprone-unchecked-optional-access)
diff --git a/nihil.uuid/uuid.ccm b/nihil.uuid/uuid.ccm
index 4aa424e..a7a4770 100644
--- a/nihil.uuid/uuid.ccm
+++ b/nihil.uuid/uuid.ccm
@@ -1,66 +1,42 @@
-/*
- * From https://github.com/mariusbancila/stduuid
- *
- * Copyright (c) 2017
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-module;
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <cstring>
-#include <functional>
-#include <iomanip>
-#include <iterator>
-#include <memory>
-#include <numeric>
-#include <optional>
-#include <random>
-#include <ranges>
-#include <span>
-#include <string>
-#include <sstream>
-#include <string_view>
-#include <type_traits>
+// From https://github.com/mariusbancila/stduuid
+//
+// Copyright (c) 2017
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
 
 export module nihil.uuid;
 
+import nihil.std;
+
 namespace nihil {
 
 template <typename TChar>
 [[nodiscard]] constexpr auto hex2char(TChar const ch) noexcept -> unsigned char
 {
 	if (ch >= static_cast<TChar>('0') && ch <= static_cast<TChar>('9'))
-		return static_cast<unsigned char>(
-				ch - static_cast<TChar>('0'));
+		return static_cast<unsigned char>(ch - static_cast<TChar>('0'));
 
 	if (ch >= static_cast<TChar>('a') && ch <= static_cast<TChar>('f'))
-		return static_cast<unsigned char>(
-				10 + ch - static_cast<TChar>('a'));
+		return static_cast<unsigned char>(10 + ch - static_cast<TChar>('a'));
 
 	if (ch >= static_cast<TChar>('A') && ch <= static_cast<TChar>('F'))
-		return static_cast<unsigned char>(
-				10 + ch - static_cast<TChar>('A'));
+		return static_cast<unsigned char>(10 + ch - static_cast<TChar>('A'));
 
 	return 0;
 }
@@ -68,17 +44,14 @@ template <typename TChar>
 template <typename TChar>
 [[nodiscard]] constexpr auto is_hex(TChar const ch) noexcept -> bool
 {
-	return	(ch >= static_cast<TChar>('0') &&
-		 ch <= static_cast<TChar>('9')) ||
-		(ch >= static_cast<TChar>('a') &&
-		 ch <= static_cast<TChar>('f')) ||
-		(ch >= static_cast<TChar>('A') &&
-		 ch <= static_cast<TChar>('F'));
+	return (ch >= static_cast<TChar>('0') && ch <= static_cast<TChar>('9')) ||
+	       (ch >= static_cast<TChar>('a') && ch <= static_cast<TChar>('f')) ||
+	       (ch >= static_cast<TChar>('A') && ch <= static_cast<TChar>('F'));
 }
 
 template <typename TChar>
-[[nodiscard]] constexpr auto to_string_view(TChar const *str) noexcept
-	-> std::basic_string_view<TChar>
+[[nodiscard]] constexpr auto
+to_string_view(TChar const *str) noexcept -> std::basic_string_view<TChar>
 {
 	if (str)
 		return str;
@@ -87,9 +60,7 @@ template <typename TChar>
 
 template <typename StringType>
 [[nodiscard]] constexpr auto to_string_view(StringType const &str) noexcept
-	-> std::basic_string_view<
-		typename StringType::value_type,
-		typename StringType::traits_type>
+	-> std::basic_string_view<typename StringType::value_type, typename StringType::traits_type>
 {
 	return str;
 }
@@ -106,9 +77,8 @@ struct sha1
 		reset();
 	}
 
-	[[nodiscard]] inline static auto
-	left_rotate(std::uint32_t value, std::size_t const count) noexcept
-		-> std::uint32_t
+	[[nodiscard]] static auto
+	left_rotate(std::uint32_t value, std::size_t const count) noexcept -> std::uint32_t
 	{
 		return (value << count) ^ (value >> (32 - count));
 	}
@@ -126,7 +96,7 @@ struct sha1
 
 	auto process_byte(this sha1 &self, std::uint8_t octet) -> void
 	{
-		self.m_block[self.m_blockByteIndex++] = octet;
+		self.m_block.at(self.m_blockByteIndex++) = octet;
 		++self.m_byteCount;
 
 		if (self.m_blockByteIndex == block_bytes) {
@@ -135,13 +105,10 @@ struct sha1
 		}
 	}
 
-	auto process_block(this sha1 &self,
-			   void const *const start,
-			   void const *const end)
-		-> void
+	auto process_block(this sha1 &self, void const *const start, void const *const end) -> void
 	{
-		auto *first = static_cast<uint8_t const *>(start);
-		auto *last = static_cast<uint8_t const *>(end);
+		auto const *first = static_cast<std::uint8_t const *>(start);
+		auto const *last = static_cast<std::uint8_t const *>(end);
 
 		while (first != last) {
 			self.process_byte(*first);
@@ -149,12 +116,9 @@ struct sha1
 		}
 	}
 
-	auto process_bytes(this sha1 &self,
-			   void const *const data,
-			   size_t const len)
-		-> void
+	auto process_bytes(this sha1 &self, void const *const data, std::size_t const len) -> void
 	{
-		auto *block = static_cast<uint8_t const *>(data);
+		auto *block = static_cast<std::uint8_t const *>(data);
 		self.process_block(block, block + len);
 	}
 
@@ -178,14 +142,10 @@ struct sha1
 		self.process_byte(0);
 		self.process_byte(0);
 		self.process_byte(0);
-		self.process_byte(static_cast<unsigned char>(
-				(bit_count >> 24) & 0xFF));
-		self.process_byte(static_cast<unsigned char>(
-				(bit_count >> 16) & 0xFF));
-		self.process_byte(static_cast<unsigned char>(
-				(bit_count >> 8) & 0xFF));
-		self.process_byte(static_cast<unsigned char>(
-				(bit_count) & 0xFF));
+		self.process_byte(static_cast<unsigned char>((bit_count >> 24U) & 0xFFU));
+		self.process_byte(static_cast<unsigned char>((bit_count >> 16U) & 0xFFU));
+		self.process_byte(static_cast<unsigned char>((bit_count >> 8U) & 0xFFU));
+		self.process_byte(static_cast<unsigned char>((bit_count) & 0xFFU));
 
 		return self.m_digest;
 	}
@@ -193,57 +153,50 @@ struct sha1
 	auto get_digest_bytes(this sha1 &self) -> digest8_t
 	{
 		auto d32 = self.get_digest();
-		auto digest = digest8_t{};
-
-		auto di = std::size_t{0};
-
-		digest[di++] = static_cast<uint8_t>(d32[0] >> 24);
-		digest[di++] = static_cast<uint8_t>(d32[0] >> 16);
-		digest[di++] = static_cast<uint8_t>(d32[0] >> 8);
-		digest[di++] = static_cast<uint8_t>(d32[0] >> 0);
 
-		digest[di++] = static_cast<uint8_t>(d32[1] >> 24);
-		digest[di++] = static_cast<uint8_t>(d32[1] >> 16);
-		digest[di++] = static_cast<uint8_t>(d32[1] >> 8);
-		digest[di++] = static_cast<uint8_t>(d32[1] >> 0);
-
-		digest[di++] = static_cast<uint8_t>(d32[2] >> 24);
-		digest[di++] = static_cast<uint8_t>(d32[2] >> 16);
-		digest[di++] = static_cast<uint8_t>(d32[2] >> 8);
-		digest[di++] = static_cast<uint8_t>(d32[2] >> 0);
-
-		digest[di++] = static_cast<uint8_t>(d32[3] >> 24);
-		digest[di++] = static_cast<uint8_t>(d32[3] >> 16);
-		digest[di++] = static_cast<uint8_t>(d32[3] >> 8);
-		digest[di++] = static_cast<uint8_t>(d32[3] >> 0);
-
-		digest[di++] = static_cast<uint8_t>(d32[4] >> 24);
-		digest[di++] = static_cast<uint8_t>(d32[4] >> 16);
-		digest[di++] = static_cast<uint8_t>(d32[4] >> 8);
-		digest[di++] = static_cast<uint8_t>(d32[4] >> 0);
-
-		return digest;
+		return {
+			static_cast<std::uint8_t>(d32[0] >> 24U),
+			static_cast<std::uint8_t>(d32[0] >> 16U),
+			static_cast<std::uint8_t>(d32[0] >> 8U),
+			static_cast<std::uint8_t>(d32[0] >> 0U),
+
+			static_cast<std::uint8_t>(d32[1] >> 24U),
+			static_cast<std::uint8_t>(d32[1] >> 16U),
+			static_cast<std::uint8_t>(d32[1] >> 8U),
+			static_cast<std::uint8_t>(d32[1] >> 0U),
+
+			static_cast<std::uint8_t>(d32[2] >> 24U),
+			static_cast<std::uint8_t>(d32[2] >> 16U),
+			static_cast<std::uint8_t>(d32[2] >> 8U),
+			static_cast<std::uint8_t>(d32[2] >> 0U),
+
+			static_cast<std::uint8_t>(d32[3] >> 24U),
+			static_cast<std::uint8_t>(d32[3] >> 16U),
+			static_cast<std::uint8_t>(d32[3] >> 8U),
+			static_cast<std::uint8_t>(d32[3] >> 0U),
+
+			static_cast<std::uint8_t>(d32[4] >> 24U),
+			static_cast<std::uint8_t>(d32[4] >> 16U),
+			static_cast<std::uint8_t>(d32[4] >> 8U),
+			static_cast<std::uint8_t>(d32[4] >> 0U),
+		};
 	}
 
 private:
 	auto process_block(this sha1 &self) -> void
 	{
-		auto w = std::array<std::uint32_t, 80>();
+		auto w = std::array<std::uint32_t, 80>{};
 
 		for (std::size_t i = 0; i < 16; i++) {
-			w[i] = static_cast<std::uint32_t>(
-					self.m_block[i * 4 + 0]) << 24;
-			w[i] |= static_cast<std::uint32_t>(
-					self.m_block[i * 4 + 1]) << 16;
-			w[i] |= static_cast<std::uint32_t>(
-					self.m_block[i * 4 + 2]) << 8;
-			w[i] |= static_cast<std::uint32_t>(
-					self.m_block[i * 4 + 3]);
+			w.at(i) = static_cast<std::uint32_t>(self.m_block.at((i * 4) + 0)) << 24U;
+			w.at(i) |= static_cast<std::uint32_t>(self.m_block.at((i * 4) + 1)) << 16U;
+			w.at(i) |= static_cast<std::uint32_t>(self.m_block.at((i * 4) + 2)) << 8U;
+			w.at(i) |= static_cast<std::uint32_t>(self.m_block.at((i * 4) + 3));
 		}
 
 		for (std::size_t i = 16; i < 80; i++) {
-			w[i] = left_rotate((w[i - 3] ^ w[i - 8] ^
-					    w[i - 14] ^ w[i - 16]), 1);
+			w.at(i) = left_rotate(
+				(w.at(i - 3) ^ w.at(i - 8) ^ w.at(i - 14) ^ w.at(i - 16)), 1);
 		}
 
 		auto a = self.m_digest[0];
@@ -270,8 +223,7 @@ private:
 				k = 0xCA62C1D6;
 			}
 
-			auto temp = std::uint32_t{left_rotate(a, 5)
-						  + f + e + k + w[i]};
+			auto temp = std::uint32_t{left_rotate(a, 5) + f + e + k + w.at(i)};
 			e = d;
 			d = c;
 			c = left_rotate(b, 30);
@@ -286,19 +238,17 @@ private:
 		self.m_digest[4] += e;
 	}
 
-	digest32_t			m_digest;
-	std::array<std::uint8_t, 64>	m_block;
-	std::size_t			m_blockByteIndex;
-	std::size_t			m_byteCount;
+	digest32_t                   m_digest{};
+	std::array<std::uint8_t, 64> m_block{};
+	std::size_t                  m_blockByteIndex{};
+	std::size_t                  m_byteCount{};
 };
 
 template <typename CharT>
-inline constexpr std::string_view empty_guid =
-	"00000000-0000-0000-0000-000000000000";
+inline constexpr std::string_view empty_guid = "00000000-0000-0000-0000-000000000000";
 
 template <>
-inline constexpr std::wstring_view empty_guid<wchar_t>
-	= L"00000000-0000-0000-0000-000000000000";
+inline constexpr std::wstring_view empty_guid<wchar_t> = L"00000000-0000-0000-0000-000000000000";
 
 template <typename CharT>
 inline constexpr std::string_view guid_encoder = "0123456789abcdef";
@@ -345,19 +295,19 @@ inline constexpr std::wstring_view guid_encoder<wchar_t> = L"0123456789abcdef";
 
 // indicated by a bit pattern in octet 8, marked with N in
 // xxxxxxxx-xxxx-xxxx-Nxxx-xxxxxxxxxxxx
-export enum struct uuid_variant {
+export enum struct uuid_variant : std::uint8_t {
 	// NCS backward compatibility (with the obsolete Apollo Network
 	// Computing System 1.5 UUID format).
 	// N bit pattern: 0xxx
 	// > the first 6 octets of the UUID are a 48-bit timestamp (the number
 	//   of 4 microsecond units of time since 1 Jan 1980 UTC);
 	// > the next 2 octets are reserved;
-	// > the next octet is the "address family"; 
+	// > the next octet is the "address family";
 	// > the final 7 octets are a 56-bit host ID in the form specified by
 	//   the address family
 	ncs,
 
-	// RFC 4122/DCE 1.1 
+	// RFC 4122/DCE 1.1
 	// N bit pattern: 10xx
 	// > big-endian byte order
 	rfc,
@@ -365,17 +315,17 @@ export enum struct uuid_variant {
 	// Microsoft Corporation backward compatibility
 	// N bit pattern: 110x
 	// > little endian byte order
-	// > formely used in the Component Object Model (COM) library      
+	// > formely used in the Component Object Model (COM) library
 	microsoft,
 
 	// reserved for possible future definition
-	// N bit pattern: 111x      
+	// N bit pattern: 111x
 	reserved
 };
 
 // indicated by a bit pattern in octet 6, marked with M in
-// xxxxxxxx-xxxx-Mxxx-xxxx-xxxxxxxxxxxx   
-export enum struct uuid_version {
+// xxxxxxxx-xxxx-Mxxx-xxxx-xxxxxxxxxxxx
+export enum struct uuid_version : std::uint8_t {
 	// only possible for nil or invalid uuids
 	none = 0,
 	// The time-based version specified in RFC 4122
@@ -393,25 +343,25 @@ export enum struct uuid_version {
 // Forward declare uuid and to_string so that we can declare to_string as a
 // friend later.
 export struct uuid;
-export template <typename CharT = char,
-	  typename Traits = std::char_traits<CharT>,
-	  typename Allocator = std::allocator<CharT>>
+export template <typename CharT = char, typename Traits = std::char_traits<CharT>,
+                 typename Allocator = std::allocator<CharT>>
 auto to_string(uuid const &id) -> std::basic_string<CharT, Traits, Allocator>;
 
 // --------------------------------------------------------------------------------------------------------------------------
 // uuid class
 // --------------------------------------------------------------------------------------------------------------------------
-export struct uuid {
+export struct uuid
+{
 	using value_type = std::uint8_t;
 
 	constexpr uuid() noexcept = default;
 
-	uuid(value_type(&arr)[16]) noexcept // NOLINT
+	uuid(value_type (&arr)[16]) noexcept // NOLINT
 	{
 		std::ranges::copy(arr, std::ranges::begin(data));
 	}
 
-	constexpr uuid(std::array<value_type, 16> const &arr) noexcept
+	explicit constexpr uuid(std::array<value_type, 16> const &arr) noexcept
 		: data{arr}
 	{
 	}
@@ -428,7 +378,7 @@ export struct uuid {
 		std::ranges::copy(bytes, std::ranges::begin(data));
 	}
 
-	template<typename ForwardIterator>
+	template <typename ForwardIterator>
 	explicit uuid(ForwardIterator first, ForwardIterator last)
 	{
 		if (std::distance(first, last) != 16)
@@ -439,11 +389,11 @@ export struct uuid {
 
 	[[nodiscard]] constexpr auto variant() const noexcept -> uuid_variant
 	{
-		if ((data[8] & 0x80) == 0x00)
+		if ((data[8] & 0x80U) == 0x00U)
 			return uuid_variant::ncs;
-		else if ((data[8] & 0xC0) == 0x80)
+		else if ((data[8] & 0xC0U) == 0x80U)
 			return uuid_variant::rfc;
-		else if ((data[8] & 0xE0) == 0xC0)
+		else if ((data[8] & 0xE0U) == 0xC0U)
 			return uuid_variant::microsoft;
 		else
 			return uuid_variant::reserved;
@@ -451,15 +401,15 @@ export struct uuid {
 
 	[[nodiscard]] constexpr auto version() const noexcept -> uuid_version
 	{
-		if ((data[6] & 0xF0) == 0x10)
+		if ((data[6] & 0xF0U) == 0x10U)
 			return uuid_version::time_based;
-		else if ((data[6] & 0xF0) == 0x20)
+		else if ((data[6] & 0xF0U) == 0x20U)
 			return uuid_version::dce_security;
-		else if ((data[6] & 0xF0) == 0x30)
+		else if ((data[6] & 0xF0U) == 0x30U)
 			return uuid_version::name_based_md5;
-		else if ((data[6] & 0xF0) == 0x40)
+		else if ((data[6] & 0xF0U) == 0x40U)
 			return uuid_version::random_number_based;
-		else if ((data[6] & 0xF0) == 0x50)
+		else if ((data[6] & 0xF0U) == 0x50U)
 			return uuid_version::name_based_sha1;
 		else
 			return uuid_version::none;
@@ -467,10 +417,7 @@ export struct uuid {
 
 	[[nodiscard]] constexpr auto is_nil() const noexcept -> bool
 	{
-		for (auto i : data)
-			if (i != 0)
-				return false;
-		return true;
+		return std::ranges::all_of(data, [](auto i) { return i == 0; });
 	}
 
 	auto swap(uuid &other) noexcept -> void
@@ -478,18 +425,14 @@ export struct uuid {
 		data.swap(other.data);
 	}
 
-	[[nodiscard]] inline auto as_bytes() const
-		-> std::span<std::byte const, 16>
+	[[nodiscard]] auto as_bytes() const -> std::span<std::byte const, 16>
 	{
 		return std::span<std::byte const, 16>(
-				reinterpret_cast<std::byte const*>(data.data()),
-				16);
+			reinterpret_cast<std::byte const *>(data.data()), 16);
 	}
 
 	template <typename StringType>
-	[[nodiscard]] constexpr static auto
-	is_valid_uuid(StringType const &in_str) noexcept
-		-> bool
+	[[nodiscard]] constexpr static auto is_valid_uuid(StringType const &in_str) noexcept -> bool
 	{
 		auto str = to_string_view(in_str);
 		auto firstDigit = true;
@@ -505,7 +448,7 @@ export struct uuid {
 		if (hasBraces && str.back() != '}')
 			return false;
 
-		for (size_t i = hasBraces; i < str.size() - hasBraces; ++i) {
+		for (std::size_t i = hasBraces; i < str.size() - hasBraces; ++i) {
 			if (str[i] == '-')
 				continue;
 
@@ -528,15 +471,14 @@ export struct uuid {
 
 	template <typename StringType>
 	[[nodiscard]] constexpr static auto
-	from_string(StringType const & in_str) noexcept
-		-> std::optional<uuid>
+	from_string(StringType const &in_str) -> std::optional<uuid>
 	{
 		auto str = to_string_view(in_str);
 		bool firstDigit = true;
-		size_t hasBraces = 0;
-		size_t index = 0;
+		auto hasBraces = std::size_t{0};
+		auto index = std::size_t{0};
 
-		std::array<uint8_t, 16> data{ { 0 } };
+		auto data = std::array<std::uint8_t, 16>{};
 
 		if (str.empty())
 			return {};
@@ -546,7 +488,7 @@ export struct uuid {
 		if (hasBraces && str.back() != '}')
 			return {};
 
-		for (size_t i = hasBraces; i < str.size() - hasBraces; ++i) {
+		for (std::size_t i = hasBraces; i < str.size() - hasBraces; ++i) {
 			if (str[i] == '-')
 				continue;
 
@@ -555,10 +497,11 @@ export struct uuid {
 			}
 
 			if (firstDigit) {
-				data[index] = static_cast<uint8_t>(hex2char(str[i]) << 4);
+				data.at(index) = static_cast<std::uint8_t>(hex2char(str[i]) << 4);
 				firstDigit = false;
 			} else {
-				data[index] = static_cast<uint8_t>(data[index] | hex2char(str[i]));
+				data.at(index) =
+					static_cast<std::uint8_t>(data.at(index) | hex2char(str[i]));
 				index++;
 				firstDigit = true;
 			}
@@ -572,19 +515,17 @@ export struct uuid {
 	}
 
 private:
-	std::array<value_type, 16> data{ { 0 } };
+	std::array<value_type, 16> data{{0}};
 
 	friend auto operator==(uuid const &, uuid const &) noexcept -> bool;
 	friend auto operator<(uuid const &, uuid const &) noexcept -> bool;
 
 	template <class Elem, class Traits>
-	friend auto operator<<(std::basic_ostream<Elem, Traits> &s,
-			       uuid const &id)
+	friend auto operator<<(std::basic_ostream<Elem, Traits> &s, uuid const &id)
 		-> std::basic_ostream<Elem, Traits> &;
 
-	template<class CharT, class Traits, class Allocator>
-	friend auto to_string(uuid const &id)
-		-> std::basic_string<CharT, Traits, Allocator>;
+	template <class CharT, class Traits, class Allocator>
+	friend auto to_string(uuid const &id) -> std::basic_string<CharT, Traits, Allocator>;
 
 	friend std::hash<uuid>;
 };
@@ -594,36 +535,35 @@ private:
 // --------------------------------------------------------------------------------------------------------------------------
 
 export [[nodiscard]]
-auto operator== (uuid const &lhs, uuid const &rhs) noexcept -> bool
+auto operator==(uuid const &lhs, uuid const &rhs) noexcept -> bool
 {
 	return lhs.data == rhs.data;
 }
 
-export [[nodiscard]] 
-auto operator!= (uuid const &lhs, uuid const &rhs) noexcept -> bool
+export [[nodiscard]]
+auto operator!=(uuid const &lhs, uuid const &rhs) noexcept -> bool
 {
 	return !(lhs == rhs);
 }
 
 export [[nodiscard]]
-auto operator< (uuid const &lhs, uuid const &rhs) noexcept -> bool
+auto operator<(uuid const &lhs, uuid const &rhs) noexcept -> bool
 {
 	return lhs.data < rhs.data;
 }
 
 export template <typename CharT, typename Traits, typename Allocator>
-[[nodiscard]] auto to_string(uuid const &id)
-	-> std::basic_string<CharT, Traits, Allocator>
+[[nodiscard]] auto to_string(uuid const &id) -> std::basic_string<CharT, Traits, Allocator>
 {
-	auto uustr = std::basic_string<CharT, Traits, Allocator>(
-		std::from_range, empty_guid<CharT>);
+	auto uustr =
+		std::basic_string<CharT, Traits, Allocator>(std::from_range, empty_guid<CharT>);
 
 	for (std::size_t i = 0, index = 0; i < 36; ++i) {
 		if (i == 8 || i == 13 || i == 18 || i == 23)
 			continue;
 
-		uustr[i] = guid_encoder<CharT>[id.data[index] >> 4 & 0x0f];
-		uustr[++i] = guid_encoder<CharT>[id.data[index] & 0x0f];
+		uustr[i] = guid_encoder<CharT>[id.data.at(index) >> 4U & 0x0FU];
+		uustr[++i] = guid_encoder<CharT>[id.data.at(index) & 0x0FU];
 		index++;
 	}
 
@@ -634,13 +574,12 @@ export template <class Elem, class Traits>
 auto operator<<(std::basic_ostream<Elem, Traits> &s, uuid const &id)
 	-> std::basic_ostream<Elem, Traits> &
 {
-	s << to_string(id);
-	return s;
+	return s << to_string(id);
 }
 
 export auto swap(uuid &lhs, uuid &rhs) noexcept -> void
 {
-	lhs.swap(rhs);   
+	lhs.swap(rhs);
 }
 
 /***********************************************************************
@@ -648,31 +587,31 @@ export auto swap(uuid &lhs, uuid &rhs) noexcept -> void
  */
 
 // Name string is a fully-qualified domain name
-export uuid uuid_namespace_dns{{
-	0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1,
-	0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
-}};
+export uuid uuid_namespace_dns{
+	{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
+         0xc8}
+};
 
 // Name string is a URL
-export uuid uuid_namespace_url{{
-	0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1,
-	0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
-}};
+export uuid uuid_namespace_url{
+	{0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
+         0xc8}
+};
 
 // Name string is an ISO OID (See https://oidref.com/,
 // https://en.wikipedia.org/wiki/Object_identifier)
-export uuid uuid_namespace_oid{{
-	0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1,
-	0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
-}};
+export uuid uuid_namespace_oid{
+	{0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
+         0xc8}
+};
 
 // Name string is an X.500 DN, in DER or a text output format (See
 // https://en.wikipedia.org/wiki/X.500,
 // https://en.wikipedia.org/wiki/Abstract_Syntax_Notation_One)
-export uuid uuid_namespace_x500{{
-	0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1,
-	0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
-}};
+export uuid uuid_namespace_x500{
+	{0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
+         0xc8}
+};
 
 /***********************************************************************
  * uuid generators
@@ -695,20 +634,16 @@ struct basic_uuid_random_generator
 
 	[[nodiscard]] auto operator()() -> uuid
 	{
-		alignas(std::uint32_t)
 		auto bytes = std::array<std::uint8_t, 16>{};
-
-		for (int i = 0; i < 16; i += 4)
-			*reinterpret_cast<std::uint32_t *>(bytes.data() + i) =
-				distribution(*generator);
+		std::ranges::generate(bytes, [&] { return distribution(*generator); });
 
 		// variant must be 10xxxxxx
-		bytes[8] &= 0xBF;
-		bytes[8] |= 0x80;
+		bytes[8] &= 0xBFU;
+		bytes[8] |= 0x80U;
 
 		// version must be 0100xxxx
-		bytes[6] &= 0x4F;
-		bytes[6] |= 0x40;
+		bytes[6] &= 0x4FU;
+		bytes[6] |= 0x40U;
 
 		return uuid{std::begin(bytes), std::end(bytes)};
 	}
@@ -749,18 +684,14 @@ private:
 	}
 
 	template <typename CharT, typename Traits>
-	auto process_characters(
-		std::basic_string_view<CharT, Traits> const str) -> void
+	auto process_characters(std::basic_string_view<CharT, Traits> const str) -> void
 	{
 		for (std::uint32_t c : str) {
-			hasher.process_byte(static_cast<std::uint8_t>(c & 0xFF));
+			hasher.process_byte(static_cast<std::uint8_t>(c & 0xFFU));
 			if constexpr (!std::is_same_v<CharT, char>) {
-				hasher.process_byte(
-					static_cast<uint8_t>((c >> 8) & 0xFF));
-				hasher.process_byte(
-					static_cast<uint8_t>((c >> 16) & 0xFF));
-				hasher.process_byte(
-					static_cast<uint8_t>((c >> 24) & 0xFF));
+				hasher.process_byte(static_cast<std::uint8_t>((c >> 8U) & 0xFFU));
+				hasher.process_byte(static_cast<std::uint8_t>((c >> 16U) & 0xFFU));
+				hasher.process_byte(static_cast<std::uint8_t>((c >> 24U) & 0xFFU));
 			}
 		}
 	}
@@ -770,17 +701,16 @@ private:
 		auto digest = hasher.get_digest_bytes();
 
 		// variant must be 0b10xxxxxx
-		digest[8] &= 0xBF;
-		digest[8] |= 0x80;
+		digest[8] &= 0xBFU;
+		digest[8] |= 0x80U;
 
 		// version must be 0b0101xxxx
-		digest[6] &= 0x5F;
-		digest[6] |= 0x50;
+		digest[6] &= 0x5FU;
+		digest[6] |= 0x50U;
 
 		return uuid(std::span(digest).subspan(0, 16));
 	}
 
-private:
 	uuid nsuuid;
 	sha1 hasher;
 };
@@ -791,15 +721,14 @@ private:
 export auto random_uuid() -> uuid
 {
 	auto rd = std::random_device();
-	auto seed_data = std::array<int, std::mt19937::state_size> {};
+	auto seed_data = std::array<int, std::mt19937::state_size>{};
 	std::ranges::generate(seed_data, std::ref(rd));
 
-	auto seq = std::seed_seq(std::ranges::begin(seed_data),
-				 std::ranges::end(seed_data));
+	auto seq = std::seed_seq(std::ranges::begin(seed_data), std::ranges::end(seed_data));
 	auto generator = std::mt19937(seq);
 	auto gen = uuid_random_generator{generator};
 
-	return gen();	
+	return gen();
 }
 
 } // namespace nihil
@@ -810,30 +739,27 @@ export template <>
 struct hash<nihil::uuid>
 {
 	using argument_type = nihil::uuid;
-	using result_type   = std::size_t;
+	using result_type = std::size_t;
 
-	[[nodiscard]] auto operator()(argument_type const &uuid) const
-		-> result_type
+	[[nodiscard]] auto operator()(argument_type const &uuid) const noexcept -> result_type
 	{
-		std::uint64_t l =
-			static_cast<uint64_t>(uuid.data[0]) << 56 |
-			static_cast<uint64_t>(uuid.data[1]) << 48 |
-			static_cast<uint64_t>(uuid.data[2]) << 40 |
-			static_cast<uint64_t>(uuid.data[3]) << 32 |
-			static_cast<uint64_t>(uuid.data[4]) << 24 |
-			static_cast<uint64_t>(uuid.data[5]) << 16 |
-			static_cast<uint64_t>(uuid.data[6]) <<  8 |
-			static_cast<uint64_t>(uuid.data[7]);
-
-		std::uint64_t h =
-			static_cast<uint64_t>(uuid.data[8])  << 56 |
-			static_cast<uint64_t>(uuid.data[9])  << 48 |
-			static_cast<uint64_t>(uuid.data[10]) << 40 |
-			static_cast<uint64_t>(uuid.data[11]) << 32 |
-			static_cast<uint64_t>(uuid.data[12]) << 24 |
-			static_cast<uint64_t>(uuid.data[13]) << 16 |
-			static_cast<uint64_t>(uuid.data[14]) <<  8 |
-			static_cast<uint64_t>(uuid.data[15]);
+		auto const l = static_cast<uint64_t>(uuid.data[0]) << 56U |
+		               static_cast<uint64_t>(uuid.data[1]) << 48U |
+		               static_cast<uint64_t>(uuid.data[2]) << 40U |
+		               static_cast<uint64_t>(uuid.data[3]) << 32U |
+		               static_cast<uint64_t>(uuid.data[4]) << 24U |
+		               static_cast<uint64_t>(uuid.data[5]) << 16U |
+		               static_cast<uint64_t>(uuid.data[6]) << 8U |
+		               static_cast<uint64_t>(uuid.data[7]);
+
+		auto const h = static_cast<uint64_t>(uuid.data[8]) << 56U |
+		               static_cast<uint64_t>(uuid.data[9]) << 48U |
+		               static_cast<uint64_t>(uuid.data[10]) << 40U |
+		               static_cast<uint64_t>(uuid.data[11]) << 32U |
+		               static_cast<uint64_t>(uuid.data[12]) << 24U |
+		               static_cast<uint64_t>(uuid.data[13]) << 16U |
+		               static_cast<uint64_t>(uuid.data[14]) << 8U |
+		               static_cast<uint64_t>(uuid.data[15]);
 
 		return std::hash<std::uint64_t>{}(l ^ h);
 	}