MetaCircularVirtualMachine.mpp

export module CppUtils.Language.MetaCircularVirtualMachine;

import std;
import CppUtils.Container.FlatHashMap;
import CppUtils.Container.MeshNetwork;
import CppUtils.Thread.SharedPtr;
import CppUtils.Execution.Event;
import CppUtils.Execution.ScopeGuard;
import CppUtils.Language.AST;
import CppUtils.String;
import CppUtils.Thread.SharedLocker;
import CppUtils.Thread.ThreadPool;
import CppUtils.Type.Specialization;

export namespace CppUtils::Language
{
	namespace v1
	{
		struct MetaCircularVirtualMachine
		{
			using Cursor = String::Cursor<std::string_view>;

			using Function = auto (*)(Cursor&, const ASTNode&, MetaCircularVirtualMachine&) -> std::expected<void, std::string_view>;

			[[nodiscard]] inline constexpr auto exists(Type::Token instruction) const noexcept -> bool
			{
				const auto range = scopes | std::views::reverse;
				auto it = std::ranges::find_if(range, [instruction](const auto scope) -> bool {
					return scope.get().exists(instruction);
				});
				return it != std::ranges::end(range);
			}

			[[nodiscard]] inline constexpr auto operator()(
				Cursor& cursor,
				const ASTNode& instruction = ASTNode{Type::hash("main")})
				-> std::expected<void, std::string_view>
			{
				using namespace String::Literals;

				if (instruction.value == "call"_token)
				{
					if (std::ranges::empty(instruction.nodes)) [[unlikely]]
						return std::unexpected{R"(Missing argument in the "call" instruction)"};
					if (auto iterator = functions.find(instruction.nodes.front().value); iterator != std::ranges::cend(functions))
						return iterator->second(cursor, instruction.nodes.front(), *this);
					else [[unlikely]]
						return std::unexpected{"Unknown function"};
				}

				auto grammar = [this, instruction]() -> std::reference_wrapper<ASTNode> {
					const auto range = scopes | std::views::reverse;
					auto it = std::ranges::find_if(range, [instruction](const auto scope) -> bool {
						return scope.get().exists(instruction.value);
					});
					return it != std::ranges::end(range) ? *it : scopes.front();
				}();
				if (not grammar.get().exists(instruction.value)) [[unlikely]]
					return std::unexpected{"Unknown lexeme"};
				auto lexemes = std::ref(grammar.get()[instruction.value].nodes);
				for (auto instructionPosition = 0uz; not exit and instructionPosition < std::ranges::size(lexemes.get()); ++instructionPosition)
				{
					const auto& lexeme = lexemes.get()[instructionPosition];
					if (auto result = operator()(cursor, lexeme); not result) [[unlikely]]
						return result;
					if (not grammar.get().exists(instruction.value)) [[unlikely]]
						return {};
					lexemes = std::ref(grammar.get()[instruction.value].nodes);
				}
				exit = false;
				return {};
			}

			[[nodiscard]] inline constexpr auto getScope(this auto&& self [[clang::lifetimebound, msvc::lifetimebound]]) noexcept -> auto&
			{
				using ScopeType = std::conditional_t<std::is_const_v<std::remove_reference_t<decltype(self)>>, const ASTNode, ASTNode>;
				return static_cast<ScopeType&>(self.scopes.back().get());
			}

			Container::FlatHashMap<Type::Token, Function> functions = {};
			ASTNode rootAst = {0uz, {ASTNode{Type::hash("main")}}};
			std::vector<std::reference_wrapper<ASTNode>> scopes = {std::ref(rootAst)};
			bool exit = false;
		};
	}

	inline namespace v2
	{
		struct MetaCircularVirtualMachine
		{
			using MeshNodePtr = Container::MeshNodePtr<Type::Token, Type::Token>;

			struct StepResult final
			{
				std::expected<MeshNodePtr, std::string_view> value;
			};

			using FunctionPointer = auto (*)(MetaCircularVirtualMachine&, MeshNodePtr) -> std::expected<MeshNodePtr, std::string_view>;

			struct Callable final
			{
				FunctionPointer pointer = nullptr;
				std::optional<std::function<StepResult(MetaCircularVirtualMachine&, MeshNodePtr)>> runtimeFunction = std::nullopt;

				constexpr Callable() noexcept = default;

				constexpr Callable(FunctionPointer functionPointer) noexcept:
					pointer{functionPointer}
				{}

				Callable(std::function<StepResult(MetaCircularVirtualMachine&, MeshNodePtr)> function):
					runtimeFunction{std::move(function)}
				{}

				constexpr auto operator()(MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) const -> StepResult
				{
					if (pointer)
						return StepResult{pointer(interpreter, instruction)};
					if not consteval
					{
						if (runtimeFunction)
							return runtimeFunction.value()(interpreter, instruction);
					}
					return StepResult{std::unexpected{"Invalid function call"}};
				}
			};

			struct Environment final
			{
				Thread::SharedLocker<Container::FlatHashMap<Type::Token, Callable>> functions;
				std::optional<Thread::ThreadPool> threadPool;
				Thread::SharedLocker<Container::FlatHashMap<std::size_t, std::shared_ptr<std::future<void>>>> threads;
				Thread::SharedLocker<Container::FlatHashMap<std::size_t, std::shared_ptr<Execution::Event>>> events;
				std::atomic<std::size_t> nextThreadId{0};
				std::atomic<std::size_t> nextEventId{0};
				Thread::SharedLocker<std::string> firstErrorMessage;
				std::atomic<bool> stopRequested{false};
			};

			MeshNodePtr context = MeshNodePtr::makeRoot(0uz);
			Thread::SharedPtr<Environment> environment;

			[[nodiscard]] static inline constexpr auto next(MeshNodePtr instruction) noexcept -> MeshNodePtr
			{
				using namespace String::Literals;
				return instruction.at("next"_token)
					.and_then([](auto branch) { return branch.front(); })
					.value_or(MeshNodePtr{});
			}

			template<class T = MetaCircularVirtualMachine>
			inline constexpr auto addFunction(Type::Token token, auto&& function) -> void
			{
				using namespace String::Literals;

				auto functions = environment->functions.uniqueAccess();
				if (not functions->contains(token))
				{
					using FunctionType = std::decay_t<decltype(function)>;
					if constexpr (std::is_convertible_v<FunctionType, FunctionPointer>)
						functions.value()[token] = Callable{static_cast<FunctionPointer>(function)};
					else if constexpr (requires { { +function } -> std::convertible_to<FunctionPointer>; })
						functions.value()[token] = Callable{+function};
					else
						functions.value()[token] = Callable{[function = std::forward<decltype(function)>(function)](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> StepResult {
							return StepResult{function(static_cast<T&>(interpreter), instruction)};
						}};
					if (not context.contains(token))
						context[token] >> MeshNodePtr::make(token);
				}
			}

			template<String::FixedString Name, class Operation>
			struct ArithmeticOperation final
			{
				static constexpr auto execute(MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view>
				{
					using namespace String::Literals;

					static constexpr auto lhsError = Name + ": Missing lhs";
					static constexpr auto rhsError = Name + ": Missing rhs";
					static constexpr auto resultError = Name + ": Missing result";

					auto lhs = instruction.at("lhs"_token).and_then([](auto branch) { return branch.front(); });
					if (not lhs)
						return std::unexpected{static_cast<std::string_view>(lhsError)};

					auto rhs = instruction.at("rhs"_token).and_then([](auto branch) { return branch.front(); });
					if (not rhs)
						return std::unexpected{static_cast<std::string_view>(rhsError)};

					auto result = instruction.at("result"_token).and_then([](auto branch) { return branch.front(); });
					if (not result)
						return std::unexpected{static_cast<std::string_view>(resultError)};

					const auto lhsValue = lhs->getValue().value();
					const auto rhsValue = rhs->getValue().value();
					result->setValue(Operation{}(lhsValue, rhsValue));

					return next(instruction);
				}
			};

			inline constexpr explicit MetaCircularVirtualMachine(Thread::SharedPtr<Environment> environment):
				environment{std::move(environment)}
			{}

			inline constexpr MetaCircularVirtualMachine():
				environment{Thread::makeShared<Environment>()}
			{
				using namespace std::literals;
				using namespace String::Literals;

				if not consteval
				{
					environment->threadPool.emplace();
					environment->threadPool->setOnError([environment = environment](std::exception_ptr exceptionPointer) {
						if (environment->stopRequested.exchange(true))
							return;

						try
						{
							if (exceptionPointer)
								std::rethrow_exception(exceptionPointer);
						}
						catch (const std::exception& exception)
						{
							environment->firstErrorMessage.uniqueAccess().value() = exception.what();
						}
						catch (...)
						{
							environment->firstErrorMessage.uniqueAccess().value() = "Unknown background error";
						}
					});
				}

				addFunction("set"_token, [](MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto targetNode = instruction.at("target"_token).and_then([](auto branch) { return branch.front(); });
					if (not targetNode)
						return std::unexpected{"set: Missing target"sv};

					auto valueNode = instruction.at("value"_token).and_then([](auto branch) { return branch.front(); });
					if (not valueNode)
						return std::unexpected{"set: Missing value"sv};

					auto value = valueNode->getValue().value();
					targetNode->setValue(value);
					return next(instruction);
				});

				addFunction("size"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto sourceNode = instruction.at("source"_token).and_then([](auto branch) { return branch.front(); }).value_or(interpreter.context);
					auto branchNameNode = instruction.at("branch"_token).and_then([](auto branch) { return branch.front(); });
					if (not branchNameNode)
						return std::unexpected{"size: Missing branch name"sv};

					auto sizeNode = instruction.at("size"_token).and_then([](auto branch) { return branch.front(); });
					if (not sizeNode)
						return std::unexpected{"size: Missing result node"sv};

					auto branchName = branchNameNode->getValue().value();
					sizeNode->setValue(std::ranges::size(sourceNode[branchName]));
					return next(instruction);
				});

				addFunction("create"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto valueNode = instruction.at("value"_token).and_then([](auto branch) { return branch.front(); });
					const auto value = valueNode ? valueNode->getValue().value() : 0uz;

					auto destinationNode = instruction.at("destination"_token).and_then([](auto branch) { return branch.front(); }).value_or(interpreter.context);
					auto branchPath = instruction.at("branch"_token);
					if (not branchPath or std::ranges::empty(branchPath.value()))
						return std::unexpected{"create: Missing branch path"sv};

					auto currentDestination = destinationNode;
					const auto& pathNodes = branchPath.value();
					for (auto i = 0uz; i < std::ranges::size(pathNodes) - 1; ++i)
					{
						auto token = pathNodes[i]->getValue().value();
						if (auto nextDestination = currentDestination[token].front(); not nextDestination)
						{
							auto intermediateNode = MeshNodePtr::make(0uz);
							currentDestination[token] >> intermediateNode;
							currentDestination = intermediateNode;
						}
						else
							currentDestination = nextDestination.value();
					}

					auto finalKey = pathNodes.back()->getValue().value();
					currentDestination[finalKey] >> MeshNodePtr::make(value);

					return next(instruction);
				});

				addFunction("reference"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto sourceNode = instruction.at("sourceBase"_token).and_then([](auto branch) { return branch.front(); }).value_or(interpreter.context);

					auto targetNode = sourceNode;
					if (auto targetBranch = instruction.at("sourcePath"_token))
					{
						for (auto node : targetBranch.value())
						{
							auto token = node.getValue().value();
							auto nextNode = targetNode.at(token).and_then([](auto branch) { return branch.front(); });
							if (not nextNode)
								return std::unexpected{"reference: Source path not found"sv};
							targetNode = nextNode.value();
						}
					}

					auto destinationNode = instruction.at("destinationBase"_token).and_then([](auto branch) { return branch.front(); }).value_or(interpreter.context);

					auto branchPath = instruction.at("destinationPath"_token);
					if (not branchPath or std::ranges::empty(branchPath.value()))
						return std::unexpected{"reference: Missing destination path"sv};

					auto currentDestination = destinationNode;
					const auto& pathNodes = branchPath.value();

					for (auto i = 0uz; i < std::ranges::size(pathNodes) - 1; ++i)
					{
						auto token = pathNodes[i]->getValue().value();
						if (auto nextDestination = currentDestination[token].front(); not nextDestination)
						{
							auto newNode = MeshNodePtr::make(0uz);
							currentDestination[token] >> newNode;
							currentDestination = newNode;
						}
						else
							currentDestination = nextDestination.value();
					}

					auto finalKey = pathNodes.back()->getValue().value();
					currentDestination[finalKey] >> targetNode;

					return next(instruction);
				});

				addFunction("jump"_token, [](MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto conditionNode = instruction.at("condition"_token).and_then([](auto branch) { return branch.front(); });
					if (not conditionNode or conditionNode->getValue().value() != 0)
						return instruction.at("next"_token).and_then([](auto branch) { return branch.front(); }).value_or(MeshNodePtr{});

					return instruction.at("else"_token)
						.and_then([](auto branch) { return branch.front(); })
						.value_or(MeshNodePtr{});
				});

				addFunction("return"_token, [](MetaCircularVirtualMachine&, MeshNodePtr) -> std::expected<MeshNodePtr, std::string_view> {
					return MeshNodePtr{};
				});

				addFunction("link"_token, [](MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					return instruction.at("source"_token).and_then([&](auto sources) {
						return instruction.at("branch"_token).and_then([&](auto branches) -> std::expected<void, std::string_view> {
							for (auto branch : branches)
								if (auto result = instruction.at("target"_token).and_then([&](auto targets) -> std::expected<void, std::string_view> {
									for (auto source : sources)
										for (auto target : targets)
											source[branch.getValue().value()] >> target;
									return {};
								});
									not result)
									return result;
							return {};
						});
					}).transform([&instruction] { return next(instruction); });
				});

				addFunction("unlink"_token, [](MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					return instruction.at("source"_token).and_then([&](auto sources) {
						return instruction.at("branch"_token).and_then([&](auto branches) -> std::expected<void, std::string_view> {
							auto targetsBranch = instruction.at("target"_token);
							for (auto source : sources)
								for (const auto& branch : branches)
									if (auto branchNodes = source[branch.getValue().value()]; targetsBranch)
										for (const auto& target : targetsBranch.value())
											branchNodes - target;
									else
										branchNodes.clear();
							return {};
						});
					}).transform([&instruction] { return next(instruction); });
				});

				addFunction("call"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto function = instruction.at("function"_token).and_then([](auto branch) { return branch.front(); });
					if (not function)
						return std::unexpected{"call: No function"sv};

					auto context = MeshNodePtr::makeRoot("context"_token);
					context["scope"_token] >> interpreter.context;

					if (auto inputs = instruction.at("input"_token))
						for (auto input : inputs.value())
							context["input"_token] >> input;

					if (auto outputs = instruction.at("output"_token))
						for (auto output : outputs.value())
							context["output"_token] >> output;

					auto previousContext = std::exchange(interpreter.context, std::move(context));
					auto result = interpreter(function.value());
					interpreter.context = std::move(previousContext);

					if (not result)
						return std::unexpected{result.error()};

					return next(instruction);
				});

				addFunction("=="_token, [](MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					return instruction.at("lhs"_token).and_then([](auto branch) { return branch.front(); }).and_then([&](MeshNodePtr lhs) {
						return instruction.at("rhs"_token).and_then([](auto branch) { return branch.front(); }).and_then([&, lhs](MeshNodePtr rhs) {
							return instruction.at("result"_token).and_then([](auto branch) { return branch.front(); }).and_then([&, lhs, rhs](MeshNodePtr result) -> std::expected<void, std::string_view> {
								const auto lhsValue = lhs.getValue().value();
								const auto rhsValue = rhs.getValue().value();
								result.setValue(lhsValue == rhsValue);
								return {};
							});
						});
					}).transform([&instruction] { return next(instruction); });
				});

				addFunction("==="_token, [](MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					return instruction.at("lhs"_token).and_then([](auto branch) { return branch.front(); }).and_then([&](MeshNodePtr lhs) {
						return instruction.at("rhs"_token).and_then([](auto branch) { return branch.front(); }).and_then([&, lhs](MeshNodePtr rhs) {
							return instruction.at("result"_token).and_then([](auto branch) { return branch.front(); }).and_then([&, lhs, rhs](MeshNodePtr result) -> std::expected<void, std::string_view> {
								result.setValue(lhs == rhs);
								return {};
							});
						});
					}).transform([&instruction] { return next(instruction); });
				});

				addFunction("not"_token, [](MetaCircularVirtualMachine&, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					return instruction.at("value"_token).and_then([](auto branch) { return branch.front(); }).and_then([&](MeshNodePtr value) -> std::expected<void, std::string_view> {
						const auto result = not static_cast<bool>(value.getValue().value());
						value.setValue(result);
						return {};
					}).transform([&instruction] { return next(instruction); });
				});

				addFunction("+"_token, ArithmeticOperation<"+", std::plus<>>::execute);
				addFunction("-"_token, ArithmeticOperation<"-", std::minus<>>::execute);
				addFunction("*"_token, ArithmeticOperation<"*", std::multiplies<>>::execute);
				addFunction("/"_token, ArithmeticOperation<"/", std::divides<>>::execute);
				addFunction("%"_token, ArithmeticOperation<"%", std::modulus<>>::execute);
				addFunction("<"_token, ArithmeticOperation<"<", std::less<>>::execute);

				addFunction("thread"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto targetInstruction = instruction.at("target"_token).and_then([](auto branch) { return branch.front(); });
					if (not targetInstruction)
						return std::unexpected{"thread: Missing target"sv};

					auto threadContext = MeshNodePtr::makeRoot("threadContext"_token);
					threadContext["scope"_token] >> interpreter.context;

					if (auto inputs = instruction.at("input"_token))
						for (auto input : inputs.value())
							threadContext["input"_token] >> input;

					if (auto outputs = instruction.at("output"_token))
						for (auto output : outputs.value())
							threadContext["output"_token] >> output;

					auto task = [target = targetInstruction.value(),
									threadContext = std::move(threadContext),
									environment = interpreter.environment,
									&interpreter]() mutable {
						auto threadInterpreter = interpreter.makeExecutionContext(std::move(environment));
						threadInterpreter->context = std::move(threadContext);

						if (auto result = (*threadInterpreter)(target); not result)
							throw std::runtime_error{std::string{result.error()}};
					};

					auto threadId = interpreter.environment->nextThreadId++;
					interpreter.environment->threads.uniqueAccess().value()[threadId] = std::make_shared<std::future<void>>(interpreter.environment->threadPool->call(task));

					auto threadIdNode = instruction.at("threadId"_token).and_then([](auto branch) { return branch.front(); });
					if (not threadIdNode)
						return std::unexpected{"thread: Missing result node"sv};

					threadIdNode->setValue(threadId);

					return next(instruction);
				});

				addFunction("join"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto threadIdNode = instruction.at("thread"_token).and_then([](auto branch) { return branch.front(); });
					if (not threadIdNode)
						return std::unexpected{"join: Missing thread id"sv};

					auto threadId = threadIdNode->getValue().value();
					auto future = [&]() -> std::shared_ptr<std::future<void>> {
						auto threads = interpreter.environment->threads.sharedAccess();
						if (auto it = threads.value().find(threadId); it != std::ranges::end(threads.value()))
							return it->second;
						return nullptr;
					}();

					if (future and future->valid())
						future->wait();

					interpreter.environment->threads.uniqueAccess().value().erase(threadId);

					return next(instruction);
				});

				addFunction("detach"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto threadIdNode = instruction.at("thread"_token).and_then([](auto branch) { return branch.front(); });
					if (not threadIdNode)
						return std::unexpected{"detach: Missing thread id"sv};

					auto threadId = threadIdNode->getValue().value();
					interpreter.environment->threads.uniqueAccess().value().erase(threadId);

					return next(instruction);
				});

				addFunction("event"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto eventIdNode = instruction.at("eventId"_token).and_then([](auto branch) { return branch.front(); });
					if (not eventIdNode)
						return std::unexpected{"event: Missing result node"sv};

					auto eventId = interpreter.environment->nextEventId++;
					interpreter.environment->events.uniqueAccess().value()[eventId] = std::make_shared<Execution::Event>();

					eventIdNode->setValue(eventId);

					return next(instruction);
				});

				addFunction("wait"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto idNode = instruction.at("event"_token).and_then([](auto branch) { return branch.front(); });
					if (not idNode)
						return std::unexpected{"wait: Missing event id"sv};

					auto id = idNode->getValue().value();
					auto event = [&]() -> std::shared_ptr<Execution::Event> {
						auto events = interpreter.environment->events.sharedAccess();
						if (auto it = events.value().find(id); it != std::ranges::end(events.value()))
							return it->second;
						return nullptr;
					}();

					if (event)
						event->wait();

					return next(instruction);
				});

				addFunction("notify"_token, [](MetaCircularVirtualMachine& interpreter, MeshNodePtr instruction) -> std::expected<MeshNodePtr, std::string_view> {
					auto idNode = instruction.at("event"_token).and_then([](auto branch) { return branch.front(); });
					if (not idNode)
						return std::unexpected{"notify: Missing event id"sv};

					auto id = idNode->getValue().value();
					auto event = [&]() -> std::shared_ptr<Execution::Event> {
						auto events = interpreter.environment->events.sharedAccess();
						if (auto it = events.value().find(id); it != std::ranges::end(events.value()))
							return it->second;
						return nullptr;
					}();

					if (event)
						event->notify();

					return next(instruction);
				});
			}

			virtual ~MetaCircularVirtualMachine() = default;

			[[nodiscard]] virtual inline auto makeExecutionContext(Thread::SharedPtr<Environment> environment) const -> std::unique_ptr<MetaCircularVirtualMachine>
			{
				return std::make_unique<MetaCircularVirtualMachine>(std::move(environment));
			}

		private:
			[[nodiscard]] inline constexpr auto resultWithBackgroundErrors(std::expected<void, std::string_view> result) const -> std::expected<void, std::string_view>
			{
				if not consteval
				{
					if (not environment->stopRequested.load())
						return result;

					if (auto firstError = environment->firstErrorMessage.sharedAccess(); not std::ranges::empty(firstError.value()))
						return std::unexpected{std::string_view{firstError.value()}};
				}
				return result;
			}

		public:
			[[nodiscard]] inline constexpr auto reportError(std::string_view message) const -> std::expected<void, std::string_view>
			{
				if not consteval
				{
					if (not environment->stopRequested.exchange(true))
						environment->firstErrorMessage.uniqueAccess().value() = message;
				}

				return resultWithBackgroundErrors(std::unexpected{message});
			}

			[[nodiscard]] inline constexpr auto get(Type::Token token) -> std::expected<MeshNodePtr, std::string_view>
			{
				using namespace std::literals;
				using namespace String::Literals;

				for (auto scope = context;
					scope;
					scope = scope.at("scope"_token).and_then([](auto stack) { return stack.front(); }).value_or(MeshNodePtr{}))
					if (auto node = scope.at(token).and_then([](auto stack) { return stack.back(); }))
						return node;

				return std::unexpected{"Unknown node"sv};
			}

			[[nodiscard]] inline constexpr auto resolve(Type::Token token) -> std::expected<MeshNodePtr, std::string_view>
			{
				using namespace std::literals;

				auto currentToken = token;
				auto lastResult = std::expected<MeshNodePtr, std::string_view>{std::unexpect, "Unknown node"sv};
				while (true)
				{
					auto found = get(currentToken);
					if (not found)
						return lastResult;

					if (lastResult and found.value() == lastResult.value())
						return found;

					const auto nextToken = found->getValue().value();
					if (nextToken == currentToken)
						return found;

					lastResult = found;
					currentToken = nextToken;
				}
			}

			[[nodiscard]] inline constexpr auto operator()(MeshNodePtr instruction) -> std::expected<void, std::string_view>
			{
				using namespace String::Literals;

				while (instruction)
				{
					if not consteval
					{
						if (environment->stopRequested.load())
							break;
					}
					auto result = resolve(instruction.getValue().value());
					auto definition = result ? result.value() : instruction;
					auto definitionToken = definition.getValue().value();

					if (auto function = [&]() -> std::optional<Callable> {
						auto functions = environment->functions.sharedAccess();
						if (auto functionIt = functions.value().find(definitionToken); functionIt != std::ranges::cend(functions.value()))
							return functionIt->second;
						return std::nullopt;
					}())
						if (auto result = function.value()(*this, instruction).value)
							instruction = result.value();
						else
							return reportError(result.error());
					else if (auto branch = definition.at("next"_token))
						instruction = branch.value().front().value_or(MeshNodePtr{});
					else
						break;
				}

				return resultWithBackgroundErrors({});
			}

			[[nodiscard]] inline constexpr auto operator()(Type::Token token) -> std::expected<void, std::string_view>
			{
				using namespace std::literals;

				if (auto instruction = get(token))
					return (*this)(instruction.value());

				if (auto function = [&]() -> std::optional<Callable> {
					auto functions = environment->functions.sharedAccess();
					if (auto functionIt = functions.value().find(token); functionIt != std::ranges::cend(functions.value()))
						return functionIt->second;
					return std::nullopt;
				}())
				{
					if (auto result = function.value()(*this, MeshNodePtr::make(token)).value)
						return resultWithBackgroundErrors((*this)(result.value()));
					else
						return reportError(result.error());
				}

				return reportError("Unknown function"sv);
			}
		};
	}
}