Auto-update pre-commit hooks (#230)

beman-automated-pr-bot[bot] · dietmarkuehl · web-flow · commit b41caf53cbe7 · 2026-03-01T18:39:45.000Z
Co-authored-by: dietmarkuehl &lt;1319703+dietmarkuehl@users.noreply.github.com&gt;
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -24,7 +24,7 @@ repos:
   # See also: https://github.com/ssciwr/clang-format-wheel
   # Config file: .clang-format
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v21.1.8
+    rev: v22.1.0
     hooks:
       - id: clang-format
         types_or: [c++, c, json, javascript]
@@ -48,7 +48,7 @@ repos:
   # Config file: pyproject.toml
   # first Python sort imports
   - repo: https://github.com/pycqa/isort
-    rev: 8.0.0
+    rev: 8.0.1
     hooks:
       - id: isort
 
diff --git a/include/beman/execution/detail/continues_on.hpp b/include/beman/execution/detail/continues_on.hpp
@@ -104,7 +104,7 @@ auto get_domain_late(Sender&& sender, Env&&) {
 #else
 template <typename Env, typename... T>
 auto get_domain_late(
-    ::beman::execution::detail::basic_sender<::beman::execution::detail::continues_on_t, T...> const& sender, Env&&) {
+    const ::beman::execution::detail::basic_sender<::beman::execution::detail::continues_on_t, T...>& sender, Env&&) {
 #endif
     auto scheduler{sender.template get<1>()};
     return ::beman::execution::detail::query_with_default(
diff --git a/include/beman/execution/detail/into_variant.hpp b/include/beman/execution/detail/into_variant.hpp
@@ -83,9 +83,9 @@ struct into_variant_t {
         static consteval auto get() {
             using variant_type = ::beman::execution::value_types_of_t<Child, Env>;
             using value_types  = ::std::conditional_t<
-                 ::std::same_as<variant_type, ::beman::execution::detail::empty_variant>,
-                 ::beman::execution::completion_signatures<>,
-                 ::beman::execution::completion_signatures<::beman::execution::set_value_t(variant_type)>>;
+                ::std::same_as<variant_type, ::beman::execution::detail::empty_variant>,
+                ::beman::execution::completion_signatures<>,
+                ::beman::execution::completion_signatures<::beman::execution::set_value_t(variant_type)>>;
 
             using error_types = ::beman::execution::error_types_of_t<Child, Env, make_error_types>;
             using stopped_types =
diff --git a/include/beman/execution/detail/let.hpp b/include/beman/execution/detail/let.hpp
@@ -240,10 +240,10 @@ struct let_t {
             using unique_t    = ::beman::execution::detail::meta::unique<tuples_t>;
             using args_t      = ::beman::execution::detail::meta::prepend<std::monostate, unique_t>;
             using ops_t       = ::beman::execution::detail::meta::prepend<
-                      ::std::monostate,
-                      ::beman::execution::detail::meta::unique<::beman::execution::detail::meta::transform<
-                          to_state<fun_t, ::std::remove_cvref_t<Receiver>, env_t>::template trans,
-                          tuples_t>>>;
+                ::std::monostate,
+                ::beman::execution::detail::meta::unique<::beman::execution::detail::meta::transform<
+                    to_state<fun_t, ::std::remove_cvref_t<Receiver>, env_t>::template trans,
+                    tuples_t>>>;
 
             struct state_t {
                 fun_t  fun;
diff --git a/include/beman/execution/detail/read_env.hpp b/include/beman/execution/detail/read_env.hpp
@@ -53,9 +53,9 @@ struct read_env_t {
         using set_value_type =
             ::beman::execution::set_value_t(decltype(::std::declval<Query>()(::std::as_const(::std::declval<Env>()))));
         using set_error_type = ::beman::execution::set_error_t(::std::exception_ptr);
-        using type           = ::std::conditional_t<noexcept(::std::declval<Query>()(::std::declval<const Env&>())),
-                                                    ::beman::execution::completion_signatures<set_value_type>,
-                                                    ::beman::execution::completion_signatures<set_value_type, set_error_type>>;
+        using type = ::std::conditional_t<noexcept(::std::declval<Query>()(::std::declval<const Env&>())),
+                                          ::beman::execution::completion_signatures<set_value_type>,
+                                          ::beman::execution::completion_signatures<set_value_type, set_error_type>>;
     };
 
   public:
diff --git a/include/beman/execution/detail/schedule_from.hpp b/include/beman/execution/detail/schedule_from.hpp
@@ -111,11 +111,11 @@ struct schedule_from_t {
         template <typename... E>
         using as_set_error = ::beman::execution::completion_signatures<::beman::execution::set_error_t(E)...>;
         using type         = ::beman::execution::detail::meta::combine<
-                    decltype(::beman::execution::get_completion_signatures(::std::declval<Sender>(), ::std::declval<Env>())),
-                    ::beman::execution::error_types_of_t<scheduler_sender, Env, as_set_error>,
-                    ::beman::execution::completion_signatures<::beman::execution::set_error_t(
+            decltype(::beman::execution::get_completion_signatures(::std::declval<Sender>(), ::std::declval<Env>())),
+            ::beman::execution::error_types_of_t<scheduler_sender, Env, as_set_error>,
+            ::beman::execution::completion_signatures<::beman::execution::set_error_t(
                 ::std::exception_ptr)> //-dk:TODO this one should be deduced
-                    >;
+            >;
     };
 
   public:
diff --git a/include/beman/execution/detail/spawn_future.hpp b/include/beman/execution/detail/spawn_future.hpp
@@ -93,11 +93,11 @@ template <typename... Sigs>
 struct spawn_future_state_base<::beman::execution::completion_signatures<Sigs...>> {
     static constexpr bool has_non_throwing_args_copy = (true && ... && non_throwing_args_copy_v<Sigs>);
     using result_t                                   = ::beman::execution::detail::meta::unique<
-                                          ::std::conditional_t<has_non_throwing_args_copy,
-                                                               ::std::variant<::std::monostate, ::beman::execution::detail::as_tuple_t<Sigs>...>,
-                                                               ::std::variant<::std::monostate,
-                                                                              ::std::tuple<::beman::execution::set_error_t, ::std::exception_ptr>,
-                                                                              ::beman::execution::detail::as_tuple_t<Sigs>...>>>;
+        ::std::conditional_t<has_non_throwing_args_copy,
+                             ::std::variant<::std::monostate, ::beman::execution::detail::as_tuple_t<Sigs>...>,
+                             ::std::variant<::std::monostate,
+                                            ::std::tuple<::beman::execution::set_error_t, ::std::exception_ptr>,
+                                            ::beman::execution::detail::as_tuple_t<Sigs>...>>>;
 
     result_t result{};
     virtual ~spawn_future_state_base()       = default;
diff --git a/tests/beman/execution/exec-associate.test.cpp b/tests/beman/execution/exec-associate.test.cpp
@@ -191,7 +191,7 @@ TEST(exec_associate) {
     {
         auto snd = test_std::just(true) | test_std::associate(expired_token{}) |
                    test_std::upon_stopped([]() noexcept { return false; });
-        auto r = test_std::sync_wait(std::move(snd));
+        auto r   = test_std::sync_wait(std::move(snd));
         ASSERT(r.has_value());
         ASSERT((std::get<0>(r.value()) == false));
     }
diff --git a/tests/beman/execution/exec-env.test.cpp b/tests/beman/execution/exec-env.test.cpp
@@ -21,7 +21,7 @@ TEST(env) {
     [[maybe_unused]] test_std::env<> e0{};
     [[maybe_unused]] test_std::env   e1{test_std::prop(test_std::get_allocator, std::allocator<int>{})};
     [[maybe_unused]] test_std::env   e2{test_std::prop(test_std::get_allocator, std::allocator<int>{}),
-                                      test_std::prop(test_std::get_stop_token, source.get_token())};
+                                        test_std::prop(test_std::get_stop_token, source.get_token())};
     [[maybe_unused]] auto            a1 = e1.query(test_std::get_allocator);
     [[maybe_unused]] auto            a2 = e2.query(test_std::get_allocator);
     [[maybe_unused]] auto            s2 = e2.query(test_std::get_stop_token);
diff --git a/tests/beman/execution/exec-stop-when.test.cpp b/tests/beman/execution/exec-stop-when.test.cpp
@@ -126,7 +126,7 @@ TEST(exec_stop_when) {
         test_std::inplace_stop_source source2;
         completion                    comp{completion::none};
         auto                          state{test_std::connect(test_detail::stop_when(sender{}, source1.get_token()),
-                                     receiver{source2.get_token(), comp})};
+                                                              receiver{source2.get_token(), comp})};
         ASSERT(comp == completion::none);
         test_std::start(state);
         ASSERT(comp == completion::none);
@@ -139,7 +139,7 @@ TEST(exec_stop_when) {
         test_std::inplace_stop_source source2;
         completion                    comp{completion::none};
         auto                          state{test_std::connect(test_detail::stop_when(sender{}, source1.get_token()),
-                                     receiver{source2.get_token(), comp})};
+                                                              receiver{source2.get_token(), comp})};
         ASSERT(comp == completion::none);
         test_std::start(state);
         ASSERT(comp == completion::none);
diff --git a/tests/beman/execution/exec-when-all.test.cpp b/tests/beman/execution/exec-when-all.test.cpp
@@ -97,7 +97,7 @@ struct test_sender {
         auto          set_error(auto&& error) && noexcept -> void {
             if constexpr (std::same_as<Tag, test_std::set_error_t> && 1u == std::tuple_size_v<Result>)
                 if constexpr (std::same_as<std::decay_t<std::tuple_element_t<0, Result>>,
-                                                    std::decay_t<decltype(error)>>)
+                                           std::decay_t<decltype(error)>>)
                     test_std::set_value(std::move(receiver), this->expect == std::tie(error));
                 else
                     test_std::set_value(std::move(receiver), false);
diff --git a/tests/beman/execution/include/test/thread_pool.hpp b/tests/beman/execution/include/test/thread_pool.hpp
@@ -48,7 +48,7 @@ struct test::thread_pool {
             std::unique_lock cerberus(mutex);
             condition.wait(cerberus, [this] { return stopped || stack; });
             return this->stack ? std::optional<node*>(std::exchange(this->stack, this->stack->next))
-                                           : std::optional<node*>();
+                               : std::optional<node*>();
         }()) {
             (*n)->run();
         }
diff --git a/tests/beman/execution/issue-186.test.cpp b/tests/beman/execution/issue-186.test.cpp
@@ -26,16 +26,16 @@ struct move_only_type {
 } // namespace
 
 TEST(issue186) {
-    auto snd = ex::just(move_only_type(1))                                      //
-               | ex::then([](move_only_type v) noexcept { return v.val * 2; })  //
-               | ex::let_value([](int v) noexcept { return ex::just(v * 3); }); // int
+    auto snd   = ex::just(move_only_type(1))                                      //
+                 | ex::then([](move_only_type v) noexcept { return v.val * 2; })  //
+                 | ex::let_value([](int v) noexcept { return ex::just(v * 3); }); // int
     auto [ret] = ex::sync_wait(std::move(snd)).value();
     assert(ret == 6);
 
     // NOTE: Compile time error with move_only_type
-    auto snd2 = ex::just(move_only_type(1))                                                     //
-                | ex::then([](move_only_type v) noexcept { return move_only_type{v.val * 2}; }) //
-                | ex::let_value([](move_only_type v) noexcept { return ex::just(v.val * 3); }); // move_only_type
+    auto snd2   = ex::just(move_only_type(1))                                                     //
+                  | ex::then([](move_only_type v) noexcept { return move_only_type{v.val * 2}; }) //
+                  | ex::let_value([](move_only_type v) noexcept { return ex::just(v.val * 3); }); // move_only_type
     auto [ret2] = ex::sync_wait(std::move(snd2)).value();
     assert(ret2 == 6);
 }

Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ TEST(exec_associate) {`
`191`	`191`	`{`
`192`	`192`	`auto snd = test_std::just(true) \| test_std::associate(expired_token{}) \|`
`193`	`193`	`test_std::upon_stopped([]() noexcept { return false; });`
`194`		`- auto r = test_std::sync_wait(std::move(snd));`
	`194`	`+ auto r = test_std::sync_wait(std::move(snd));`
`195`	`195`	`ASSERT(r.has_value());`
`196`	`196`	`ASSERT((std::get<0>(r.value()) == false));`
`197`	`197`	`}`