// 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::count_if;
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::fold_left;
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::constructible_from;
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;
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::basic_format_arg;
using std::basic_format_args;
using std::basic_format_context;
using std::basic_format_parse_context;
using std::basic_format_string;
using std::format;
using std::format_args;
using std::format_context;
using std::format_error;
using std::format_kind;
using std::format;
using std::format_to;
using std::format_to_n;
using std::format_to_n_result;
using std::formattable;
using std::formatted_size;
using std::formatter;
using std::make_format_args;
using std::make_wformat_args;
using std::range_format;
using std::range_formatter;
using std::visit_format_arg;
using std::wformat_parse_context;
using std::format_error;
using std::runtime_format;

// <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;
using std::vprint_nonunicode;
using std::vprint_unicode;

// <random>
using std::default_random_engine;
using std::random_device;
using std::mt19937;
using std::ranlux24;
using std::ranlux24_base;
using std::ranlux48;
using std::ranlux48_base;
using std::uniform_int_distribution;

using std::seed_seq;

// <ranges>
using std::from_range;
using std::from_range_t;

namespace ranges {
using std::ranges::iterator_t;
//using std::ranges::const_iterator_t; // not in libc++
using std::ranges::sentinel_t;
//using std::ranges::const_sentinel_t; // not in libc++
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::distance;
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::drop_view;
using std::ranges::split_view;
using std::ranges::take_while_view;
using std::ranges::transform_view;
using std::ranges::values_view;
using std::ranges::operator|;
using std::ranges::to;

namespace views {
using std::ranges::views::drop;
using std::ranges::views::split;
using std::ranges::views::take_while;
using std::ranges::views::transform;
using std::ranges::views::values;
} // 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_copy_constructible;
using std::is_copy_constructible_v;
using std::is_copy_assignable;
using std::is_copy_assignable_v;
using std::is_default_constructible;
using std::is_default_constructible_v;
using std::is_move_constructible;
using std::is_move_constructible_v;
using std::is_move_assignable;
using std::is_move_assignable_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)