From 9a4f0a92d987c29dd33364260dd0231847c0a8cc Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Thu, 2 Oct 2025 14:09:52 -0600
Subject: [PATCH 1/3] :arrow_up: Update mermaid

Problem:
- Mermaid is updated upstream.

Solution:
- Apply the update here.
---
 .github/workflows/asciidoctor-ghpages.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/asciidoctor-ghpages.yml b/.github/workflows/asciidoctor-ghpages.yml
index 9f347fe..45cc5a2 100644
--- a/.github/workflows/asciidoctor-ghpages.yml
+++ b/.github/workflows/asciidoctor-ghpages.yml
@@ -42,7 +42,7 @@ jobs:
 
       - name: Install Mermaid
         run: |
-          npm install -g @mermaid-js/mermaid-cli@11.4.2
+          npm install -g @mermaid-js/mermaid-cli@11.12.0
           npx puppeteer browsers install chrome-headless-shell
 
       - name: Install asciidoctor

From d1c55e3c03e83ce13576eeb42cd53f50f0d772fc Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Thu, 2 Oct 2025 14:11:12 -0600
Subject: [PATCH 2/3] :art: Make `function_traits` available in freestanding

Problem:
- `function_traits` uses `std::function` which is not available in freestanding
  implementations.

Solution:
- Rewrite `function_traits` to avoid relying on `std::function`.

Note:
- We do not deal with `noexcept`-qualified functions here.
---
 .gitignore                       |   2 +-
 docs/for_each_n_args.adoc        |   2 -
 docs/function_traits.adoc        |   2 -
 include/stdx/function_traits.hpp | 130 ++++++++++++++++++++---
 test/function_traits.cpp         | 177 +++++++++++++++++++++++++++++++
 usage_test/main.cpp              |   2 -
 6 files changed, 291 insertions(+), 24 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6152536..a9aa622 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,7 @@ build/
 /venv
 /.vscode
 /.idea
-/.cache
+.cache/
 /.DS_Store
 .clang-format
 .clang-tidy
diff --git a/docs/for_each_n_args.adoc b/docs/for_each_n_args.adoc
index e532e76..b875c65 100644
--- a/docs/for_each_n_args.adoc
+++ b/docs/for_each_n_args.adoc
@@ -5,8 +5,6 @@ https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/for_each_n_ar
 provides a method for calling a function (or other callable) with batches of
 arguments from a parameter pack.
 
-IMPORTANT: `for_each_n_args` is not yet available on freestanding implementations.
-
 Examples:
 [source,cpp]
 ----
diff --git a/docs/function_traits.adoc b/docs/function_traits.adoc
index d95cefa..0a1b97a 100644
--- a/docs/function_traits.adoc
+++ b/docs/function_traits.adoc
@@ -5,8 +5,6 @@ https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/function_trai
 contains type traits for introspecting function signatures. It works with
 functions, lambda expressions, and classes with `operator()`.
 
-IMPORTANT: Function traits are not yet available on freestanding implementations.
-
 Examples:
 [source,cpp]
 ----
diff --git a/include/stdx/function_traits.hpp b/include/stdx/function_traits.hpp
index ae2cb9e..9fc2e2e 100644
--- a/include/stdx/function_traits.hpp
+++ b/include/stdx/function_traits.hpp
@@ -5,32 +5,136 @@
 #include <boost/mp11/algorithm.hpp>
 #include <boost/mp11/utility.hpp>
 
-#include <functional>
 #include <type_traits>
 #include <utility>
 
 namespace stdx {
 inline namespace v1 {
 namespace detail {
-template <typename...> struct function_traits;
+template <auto> struct any_type {
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    template <typename T> operator T();
+};
 
-template <typename R, typename... Args>
-struct function_traits<std::function<R(Args...)>> {
+template <typename F> struct function_traits;
+
+template <typename R, typename... Args> struct function_traits<R(Args...)> {
     using return_type = R;
 
     template <template <typename...> typename List> using args = List<Args...>;
     template <template <typename...> typename List>
     using decayed_args = List<std::decay_t<Args>...>;
     using arity = std::integral_constant<std::size_t, sizeof...(Args)>;
+    using obj_t = void;
 
     template <auto N> using nth_arg = nth_t<N, Args...>;
     template <auto N> using decayed_nth_arg = std::decay_t<nth_arg<N>>;
+
+    template <std::size_t... Is>
+    constexpr static auto invoke(std::index_sequence<Is...>)
+        -> std::invoke_result_t<R(Args...), any_type<Is>...>;
+};
+
+template <typename R, typename... Args>
+struct function_traits<R (*)(Args...)> : function_traits<R(Args...)> {};
+
+template <typename R, typename... Args>
+struct function_traits<R (*const)(Args...)> : function_traits<R(Args...)> {};
+
+template <typename R, typename... Args>
+struct function_traits<R (*volatile)(Args...)> : function_traits<R(Args...)> {};
+
+template <typename R, typename... Args>
+struct function_traits<R (*const volatile)(Args...)>
+    : function_traits<R(Args...)> {};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...)> : function_traits<R(Args...)> {
+    using obj_t = C;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) &> : function_traits<R(Args...)> {
+    using obj_t = C &;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) const &>
+    : function_traits<R(Args...)> {
+    using obj_t = C const &;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) volatile &>
+    : function_traits<R(Args...)> {
+    using obj_t = C volatile &;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) const volatile &>
+    : function_traits<R(Args...)> {
+    using obj_t = C const volatile &;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) &&> : function_traits<R(Args...)> {
+    using obj_t = C &&;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) const &&>
+    : function_traits<R(Args...)> {
+    using obj_t = C const &&;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) volatile &&>
+    : function_traits<R(Args...)> {
+    using obj_t = C volatile &&;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) const volatile &&>
+    : function_traits<R(Args...)> {
+    using obj_t = C const volatile &&;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) const> : function_traits<R(Args...)> {
+    using obj_t = C const;
+};
+
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) volatile>
+    : function_traits<R(Args...)> {
+    using obj_t = C volatile;
 };
-} // namespace detail
 
+template <typename C, typename R, typename... Args>
+struct function_traits<R (C::*)(Args...) const volatile>
+    : function_traits<R(Args...)> {
+    using obj_t = C const volatile;
+};
+
+template <typename F, typename = void> struct detect_call_operator {
+    template <std::size_t... Is>
+    constexpr static auto invoke(std::index_sequence<Is...>) ->
+        typename boost::mp11::mp_cond<
+            boost::mp11::mp_valid<std::invoke_result_t, F &&, any_type<Is>...>,
+            boost::mp11::mp_defer<std::invoke_result_t, F &&, any_type<Is>...>,
+            boost::mp11::mp_valid<std::invoke_result_t, F &, any_type<Is>...>,
+            boost::mp11::mp_defer<std::invoke_result_t, F &,
+                                  any_type<Is>...>>::type;
+};
 template <typename F>
-using function_traits =
-    detail::function_traits<decltype(std::function{std::declval<F>()})>;
+struct detect_call_operator<
+    F, std::void_t<decltype(&remove_cvref_t<F>::operator())>>
+    : function_traits<decltype(&remove_cvref_t<F>::operator())> {};
+
+template <typename F> struct function_traits : detect_call_operator<F> {};
+} // namespace detail
+
+template <typename F> using function_traits = detail::function_traits<F>;
 
 template <typename F> using return_t = typename function_traits<F>::return_type;
 template <typename F, template <typename...> typename List>
@@ -39,6 +143,7 @@ template <typename F, template <typename...> typename List>
 using decayed_args_t = typename function_traits<F>::template decayed_args<List>;
 template <typename F>
 using nongeneric_arity_t = typename function_traits<F>::arity;
+template <typename F> using obj_arg_t = typename function_traits<F>::obj_t;
 
 template <typename F, auto N>
 using nth_arg_t = typename function_traits<F>::template nth_arg<N>;
@@ -47,18 +152,9 @@ using decayed_nth_arg_t =
     typename function_traits<F>::template decayed_nth_arg<N>;
 
 namespace detail {
-template <auto> struct any_type {
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    template <typename T> operator T();
-};
-
-template <typename F, std::size_t... Is>
-constexpr auto try_invoke_impl(std::index_sequence<Is...>)
-    -> std::invoke_result_t<F, any_type<Is>...>;
-
 template <typename F, typename N>
 using try_invoke =
-    decltype(try_invoke_impl<F>(std::make_index_sequence<N::value>{}));
+    decltype(function_traits<F>::invoke(std::make_index_sequence<N::value>{}));
 
 template <typename F, typename N>
 using has_arg_count = boost::mp11::mp_valid<try_invoke, F, N>;
diff --git a/test/function_traits.cpp b/test/function_traits.cpp
index 18185d4..2d1c130 100644
--- a/test/function_traits.cpp
+++ b/test/function_traits.cpp
@@ -24,6 +24,33 @@ TEST_CASE("function return type", "[function_traits]") {
     STATIC_REQUIRE(std::is_same_v<stdx::return_t<decltype(func_one_arg)>, int>);
 }
 
+TEST_CASE("function pointer return type", "[function_traits]") {
+    STATIC_REQUIRE(
+        std::is_void_v<typename stdx::function_traits<
+            std::add_pointer_t<decltype(func_no_args)>>::return_type>);
+    STATIC_REQUIRE(std::is_void_v<
+                   stdx::return_t<std::add_pointer_t<decltype(func_no_args)>>>);
+
+    STATIC_REQUIRE(
+        std::is_same_v<typename stdx::function_traits<std::add_pointer_t<
+                           decltype(func_one_arg)>>::return_type,
+                       int>);
+    STATIC_REQUIRE(
+        std::is_same_v<
+            stdx::return_t<std::add_pointer_t<decltype(func_one_arg)>>, int>);
+}
+
+TEST_CASE("qualified function pointer return type", "[function_traits]") {
+    STATIC_REQUIRE(
+        std::is_void_v<
+            stdx::return_t<std::add_pointer_t<decltype(func_no_args)> const>>);
+    STATIC_REQUIRE(std::is_void_v<stdx::return_t<
+                       std::add_pointer_t<decltype(func_no_args)> volatile>>);
+    STATIC_REQUIRE(
+        std::is_void_v<stdx::return_t<
+            std::add_pointer_t<decltype(func_no_args)> const volatile>>);
+}
+
 TEST_CASE("lambda return type", "[function_traits]") {
     [[maybe_unused]] auto const x = []() {};
     [[maybe_unused]] auto const y = []() mutable {};
@@ -197,3 +224,153 @@ TEST_CASE("SFINAE friendly", "[function_traits]") {
     call_f(f2, stdx::priority<1>);
     CHECK(called_2 == 1);
 }
+
+namespace {
+struct S {
+    [[maybe_unused]] auto f() -> void {}
+};
+struct S_C {
+    [[maybe_unused]] auto f() const -> void {}
+};
+struct S_V {
+    [[maybe_unused]] auto f() volatile -> void {}
+};
+struct S_CV {
+    [[maybe_unused]] auto f() const volatile -> void {}
+};
+
+struct S_LV {
+    [[maybe_unused]] auto f() & -> void {}
+};
+struct S_RV {
+    [[maybe_unused]] auto f() && -> void {}
+};
+struct S_CLV {
+    [[maybe_unused]] auto f() const & -> void {}
+};
+struct S_CRV {
+    [[maybe_unused]] auto f() const && -> void {}
+};
+
+struct S_VLV {
+    [[maybe_unused]] auto f() volatile & -> void {}
+};
+struct S_VRV {
+    [[maybe_unused]] auto f() volatile && -> void {}
+};
+
+struct S_CVLV {
+    [[maybe_unused]] auto f() const volatile & -> void {}
+};
+struct S_CVRV {
+    [[maybe_unused]] auto f() const volatile && -> void {}
+};
+} // namespace
+
+TEST_CASE("member function return type", "[function_traits]") {
+    STATIC_REQUIRE(std::is_void_v<stdx::return_t<decltype(&S::f)>>);
+    STATIC_REQUIRE(std::is_void_v<stdx::return_t<decltype(&S_C::f)>>);
+    STATIC_REQUIRE(std::is_void_v<stdx::return_t<decltype(&S_V::f)>>);
+    STATIC_REQUIRE(std::is_void_v<stdx::return_t<decltype(&S_CV::f)>>);
+}
+
+TEST_CASE("member function arity", "[function_traits]") {
+    STATIC_REQUIRE(stdx::arity_v<decltype(&S::f)> == 0);
+    STATIC_REQUIRE(stdx::arity_v<decltype(&S_C::f)> == 0);
+    STATIC_REQUIRE(stdx::arity_v<decltype(&S_V::f)> == 0);
+    STATIC_REQUIRE(stdx::arity_v<decltype(&S_CV::f)> == 0);
+}
+
+TEST_CASE("object argument types (const/volatile)", "[function_traits]") {
+    STATIC_REQUIRE(std::is_void_v<stdx::obj_arg_t<decltype(&func_no_args)>>);
+    STATIC_REQUIRE(std::is_same_v<S, stdx::obj_arg_t<decltype(&S::f)>>);
+    STATIC_REQUIRE(
+        std::is_same_v<S_C const, stdx::obj_arg_t<decltype(&S_C::f)>>);
+    STATIC_REQUIRE(
+        std::is_same_v<S_V volatile, stdx::obj_arg_t<decltype(&S_V::f)>>);
+    STATIC_REQUIRE(std::is_same_v<S_CV const volatile,
+                                  stdx::obj_arg_t<decltype(&S_CV::f)>>);
+}
+
+TEST_CASE("object argument types (value categories)", "[function_traits]") {
+    STATIC_REQUIRE(std::is_same_v<S_LV &, stdx::obj_arg_t<decltype(&S_LV::f)>>);
+    STATIC_REQUIRE(
+        std::is_same_v<S_RV &&, stdx::obj_arg_t<decltype(&S_RV::f)>>);
+    STATIC_REQUIRE(
+        std::is_same_v<S_CLV const &, stdx::obj_arg_t<decltype(&S_CLV::f)>>);
+    STATIC_REQUIRE(
+        std::is_same_v<S_CRV const &&, stdx::obj_arg_t<decltype(&S_CRV::f)>>);
+
+    STATIC_REQUIRE(
+        std::is_same_v<S_VLV volatile &, stdx::obj_arg_t<decltype(&S_VLV::f)>>);
+    STATIC_REQUIRE(std::is_same_v<S_VRV volatile &&,
+                                  stdx::obj_arg_t<decltype(&S_VRV::f)>>);
+    STATIC_REQUIRE(std::is_same_v<S_CVLV const volatile &,
+                                  stdx::obj_arg_t<decltype(&S_CVLV::f)>>);
+    STATIC_REQUIRE(std::is_same_v<S_CVRV const volatile &&,
+                                  stdx::obj_arg_t<decltype(&S_CVRV::f)>>);
+}
+
+TEST_CASE("object argument type (lambda)", "[function_traits]") {
+    [[maybe_unused]] auto const x = [](int) {};
+    STATIC_REQUIRE(std::is_same_v<decltype(x), stdx::obj_arg_t<decltype(x)>>);
+}
+
+namespace {
+struct TS {
+    template <typename T> auto operator()(T) -> void {}
+};
+struct TS_C {
+    template <typename T> auto operator()(T) const -> void {}
+};
+struct TS_V {
+    template <typename T> auto operator()(T) volatile -> void {}
+};
+struct TS_CV {
+    template <typename T> auto operator()(T) const volatile -> void {}
+};
+
+struct TS_LV {
+    template <typename T> auto operator()(T) & -> void {}
+};
+struct TS_RV {
+    template <typename T> auto operator()(T) && -> void {}
+};
+struct TS_CLV {
+    template <typename T> auto operator()(T) const & -> void {}
+};
+struct TS_CRV {
+    template <typename T> auto operator()(T) const && -> void {}
+};
+
+struct TS_VLV {
+    template <typename T> auto operator()(T) volatile & -> void {}
+};
+struct TS_VRV {
+    template <typename T> auto operator()(T) volatile && -> void {}
+};
+
+struct TS_CVLV {
+    template <typename T> auto operator()(T) const volatile & -> void {}
+};
+struct TS_CVRV {
+    template <typename T> auto operator()(T) const volatile && -> void {}
+};
+} // namespace
+
+TEST_CASE("member function template arity", "[function_traits]") {
+    STATIC_REQUIRE(stdx::arity_v<TS> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_C> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_V> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_CV> == 1);
+
+    STATIC_REQUIRE(stdx::arity_v<TS_LV> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_RV> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_CLV> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_CRV> == 1);
+
+    STATIC_REQUIRE(stdx::arity_v<TS_VLV> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_VRV> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_CVLV> == 1);
+    STATIC_REQUIRE(stdx::arity_v<TS_CVRV> == 1);
+}
diff --git a/usage_test/main.cpp b/usage_test/main.cpp
index 948141e..4792cb5 100644
--- a/usage_test/main.cpp
+++ b/usage_test/main.cpp
@@ -19,10 +19,8 @@
 #include <stdx/cx_set.hpp>
 #include <stdx/cx_vector.hpp>
 #include <stdx/env.hpp>
-#ifndef SIMULATE_FREESTANDING
 #include <stdx/for_each_n_args.hpp>
 #include <stdx/function_traits.hpp>
-#endif
 #include <stdx/functional.hpp>
 #include <stdx/intrusive_forward_list.hpp>
 #include <stdx/intrusive_list.hpp>

From 93286497eabc44debe967270c1d76e326af54917 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Thu, 2 Oct 2025 17:13:33 -0600
Subject: [PATCH 3/3] :robot: Fix clang-format issues

Problem:
- LLVM 21.1.3 changes some minor clang-format rules.

Solution:
- Reformat the affected code.
---
 include/stdx/bit.hpp              | 3 +--
 include/stdx/tuple_algorithms.hpp | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/include/stdx/bit.hpp b/include/stdx/bit.hpp
index 44e8d90..6fdf733 100644
--- a/include/stdx/bit.hpp
+++ b/include/stdx/bit.hpp
@@ -438,8 +438,7 @@ template <std::size_t N> using smallest_uint_t = decltype(smallest_uint<N>());
 
 namespace bit_detail {
 template <std::size_t... Offsets>
-constexpr auto shifts =
-    []() -> std::array<std::size_t, sizeof...(Offsets) + 1> {
+constexpr auto shifts = []()->std::array<std::size_t, sizeof...(Offsets) + 1> {
     constexpr auto offsets = std::array{std::size_t{}, Offsets...};
     auto s = std::array<std::size_t, sizeof...(Offsets) + 1>{};
     for (auto i = std::size_t{}; i < sizeof...(Offsets); ++i) {
diff --git a/include/stdx/tuple_algorithms.hpp b/include/stdx/tuple_algorithms.hpp
index 2f4e452..a1ba123 100644
--- a/include/stdx/tuple_algorithms.hpp
+++ b/include/stdx/tuple_algorithms.hpp
@@ -230,7 +230,7 @@ constexpr auto contains_type(
 template <tuplelike T, template <typename> typename Proj = std::type_identity_t>
 [[nodiscard]] constexpr auto sorted_indices() {
     return []<std::size_t... Is>(std::index_sequence<Is...>)
-               -> std::array<std::size_t, sizeof...(Is)> {
+        ->std::array<std::size_t, sizeof...(Is)> {
         using P = std::pair<std::string_view, std::size_t>;
         auto a = std::array<P, sizeof...(Is)>{
             P{stdx::type_as_string<Proj<tuple_element_t<Is, T>>>(), Is}...};