diff --git a/docs/questions.md b/docs/questions.md
index 1791f952..601b0463 100644
--- a/docs/questions.md
+++ b/docs/questions.md
@@ -42,4 +42,5 @@ likely observable.
 - [exec.sync_wait] are sync_wait(just_error(17)) and sync_wait(just_stopped())
     supposed to work? I don't see a reason why a value completion is necessarily
     required. As is, they are not because type_idenity_t ends up being used without
-    argument.
\ No newline at end of file
+    argument.
+- [exec.then] p5 seems to miss a space betweend sendr and out_sndr
\ No newline at end of file
diff --git a/include/beman/execution26/detail/basic_sender.hpp b/include/beman/execution26/detail/basic_sender.hpp
index e751a8ed..ac33fb06 100644
--- a/include/beman/execution26/detail/basic_sender.hpp
+++ b/include/beman/execution26/detail/basic_sender.hpp
@@ -72,25 +72,25 @@ namespace beman::execution26::detail
 #if __cpp_explicit_this_parameter < 202110L
         template <typename Env>
         auto get_completion_signatures(Env&&) &&
-            -> ::beman::execution26::detail::completion_signatures_for<basic_sender&&, Env>
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env>
         {
             return {};
         }
         template <typename Env>
         auto get_completion_signatures(Env&&) const&&
-            -> ::beman::execution26::detail::completion_signatures_for<basic_sender const&&, Env>
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env>
         {
             return {};
         }
         template <typename Env>
         auto get_completion_signatures(Env&&) &
-            -> ::beman::execution26::detail::completion_signatures_for<basic_sender&, Env>
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env>
         {
             return {};
         }
         template <typename Env>
         auto get_completion_signatures(Env&&) const& 
-            -> ::beman::execution26::detail::completion_signatures_for<basic_sender const&, Env>
+            -> ::beman::execution26::detail::completion_signatures_for<basic_sender, Env>
         {
             return {};
         }
diff --git a/include/beman/execution26/detail/common.hpp b/include/beman/execution26/detail/common.hpp
index 4c2b9a4f..ca5af078 100644
--- a/include/beman/execution26/detail/common.hpp
+++ b/include/beman/execution26/detail/common.hpp
@@ -8,6 +8,7 @@
 
 #if defined(__GNUC__)
 #    pragma GCC diagnostic ignored "-Wmissing-braces"
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
 #endif
 
 #if defined(__clang__)
diff --git a/include/beman/execution26/detail/meta_transform.hpp b/include/beman/execution26/detail/meta_transform.hpp
new file mode 100644
index 00000000..c339a1d0
--- /dev/null
+++ b/include/beman/execution26/detail/meta_transform.hpp
@@ -0,0 +1,34 @@
+// include/beman/execution26/detail/meta_transform.hpp                -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_BEMAN_EXECUTION26_DETAIL_META_TRANSFORM
+#define INCLUDED_BEMAN_EXECUTION26_DETAIL_META_TRANSFORM
+
+#include <beman/execution26/detail/meta_contains.hpp>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution26::detail::meta::detail
+{
+    template <template <typename> class Transform, typename List> struct transform;
+
+    template <template <typename> class Transform,
+              template <typename... T> class List,
+              typename... T>
+    struct transform<Transform, List<T...>>
+    {
+        using type = List<Transform<T>...>;
+    };
+}
+
+namespace beman::execution26::detail::meta
+{
+    template <template <typename> class Transform, typename List>
+    using transform = typename
+        ::beman::execution26::detail::meta::detail::transform<Transform, List>
+        ::type;
+}
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution26/detail/meta_unique.hpp b/include/beman/execution26/detail/meta_unique.hpp
index 9b234a8d..ffc1cfaf 100644
--- a/include/beman/execution26/detail/meta_unique.hpp
+++ b/include/beman/execution26/detail/meta_unique.hpp
@@ -13,28 +13,35 @@
 
 namespace beman::execution26::detail::meta::detail
 {
+    template <typename, typename> struct make_unique;
     template <typename> struct unique;
 
-    template <template <typename...> class List>
-    struct unique<List<>>
+    template <template <typename...> class List, typename... R>
+    struct make_unique<List<R...>, List<>>
     {
-        using type = List<>;
+        using type = List<R...>;
     };
-    template <template <typename...> class List, typename T>
-    struct unique<List<T>>
+
+    template <template <typename...> class List, typename... R, typename H, typename... T>
+    struct make_unique<List<R...>, List<H, T...>>
     {
-        using type = List<T>;
+        using type = typename ::beman::execution26::detail::meta::detail::make_unique<
+            ::std::conditional_t<
+                ::beman::execution26::detail::meta::contains<H, R...>,
+                List<R...>,
+                List<R..., H>
+            >,
+            List<T...>
+        >::type;
     };
 
-    template <template <typename...> class List, typename H, typename... T>
-    struct unique<List<H, T...>>
+    template <template <typename...> class List, typename... T>
+    struct unique<List<T...>>
     {
-        using tail = ::beman::execution26::detail::meta::detail::unique<List<T...>>::type;
-        using type = ::std::conditional_t<
-            ::beman::execution26::detail::meta::contains<H, T...>,
-            tail,
-            ::beman::execution26::detail::meta::prepend<H, tail>
-            >;
+        using type = typename ::beman::execution26::detail::meta::detail::make_unique<
+            List<>,
+            List<T...>
+        >::type;
     };
 }
 
diff --git a/include/beman/execution26/detail/sender_adaptor.hpp b/include/beman/execution26/detail/sender_adaptor.hpp
index a84e9ad5..8e05f80b 100644
--- a/include/beman/execution26/detail/sender_adaptor.hpp
+++ b/include/beman/execution26/detail/sender_adaptor.hpp
@@ -42,6 +42,8 @@ namespace beman::execution26::detail
             return apply(::std::forward<Sender>(sender), *this);
         }
     };
+    template <typename... T>
+    sender_adaptor(T&&...) -> sender_adaptor<T...>;
 }
 
 // ----------------------------------------------------------------------------
diff --git a/include/beman/execution26/detail/then.hpp b/include/beman/execution26/detail/then.hpp
new file mode 100644
index 00000000..623b89f6
--- /dev/null
+++ b/include/beman/execution26/detail/then.hpp
@@ -0,0 +1,175 @@
+// include/beman/execution26/detail/then.hpp                          -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_BEMAN_EXECUTION26_DETAIL_THEN
+#define INCLUDED_BEMAN_EXECUTION26_DETAIL_THEN
+
+#include <beman/execution26/detail/call_result_t.hpp>
+#include <beman/execution26/detail/completion_signatures.hpp>
+#include <beman/execution26/detail/completion_signatures_for.hpp>
+#include <beman/execution26/detail/completion_signatures_of_t.hpp>
+#include <beman/execution26/detail/default_impls.hpp>
+#include <beman/execution26/detail/get_domain_early.hpp>
+#include <beman/execution26/detail/impls_for.hpp>
+#include <beman/execution26/detail/make_sender.hpp>
+#include <beman/execution26/detail/meta_transform.hpp>
+#include <beman/execution26/detail/meta_unique.hpp>
+#include <beman/execution26/detail/movable_value.hpp>
+#include <beman/execution26/detail/sender.hpp>
+#include <beman/execution26/detail/sender_adaptor.hpp>
+#include <beman/execution26/detail/sender_adaptor_closure.hpp>
+#include <beman/execution26/detail/set_error.hpp>
+#include <beman/execution26/detail/set_stopped.hpp>
+#include <beman/execution26/detail/set_value.hpp>
+#include <beman/execution26/detail/transform_sender.hpp>
+#include <concepts>
+#include <exception>
+#include <functional>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution26::detail
+{
+    template <typename Completion>
+    struct then_t
+        : ::beman::execution26::sender_adaptor_closure<then_t<Completion>>
+    {
+        template <::beman::execution26::detail::movable_value Fun>
+        auto operator()(Fun&& fun) const
+        {
+            return ::beman::execution26::detail::sender_adaptor{
+                *this, ::std::forward<Fun>(fun)
+            };
+        }
+        template <::beman::execution26::sender Sender,
+                  ::beman::execution26::detail::movable_value Fun>
+        auto operator()(Sender&& sender, Fun&& fun) const
+        {
+            auto domain{::beman::execution26::detail::get_domain_early(sender)};
+            return ::beman::execution26::transform_sender(
+                domain,
+                ::beman::execution26::detail::make_sender(
+                    *this,
+                    ::std::forward<Fun>(fun),
+                    ::std::forward<Sender>(sender)
+                )
+            );
+        }
+    };
+
+    template <typename Completion>
+    struct impls_for<then_t<Completion>>
+        : ::beman::execution26::detail::default_impls
+    {
+        static constexpr auto complete
+            = []<typename Tag, typename... Args>
+                (auto, auto& fun, auto& receiver, Tag, Args&&... args)
+                noexcept
+                -> void
+            {
+                if constexpr (::std::same_as<Completion, Tag>)
+                {
+                    try
+                    {
+                        auto invoke = [&]{
+                            return ::std::invoke(::std::move(fun),
+                                                 ::std::forward<Args>(args)...);
+                        };
+                        if constexpr (::std::same_as<void, decltype(invoke())>)
+                        {
+                            invoke();
+                            ::beman::execution26::set_value(
+                                ::std::move(receiver)
+                            );
+                        }
+                        else
+                        {
+                            ::beman::execution26::set_value(
+                                ::std::move(receiver),
+                                invoke()
+                            );
+                        }
+                    }
+                    catch (...)
+                    {
+                        ::beman::execution26::set_error(
+                            ::std::move(receiver),
+                            ::std::current_exception()
+                        );
+                    }
+                }
+                else
+                {
+                    Tag()(::std::move(receiver), ::std::forward<Args>(args)...);
+                }
+            };
+    };
+
+    template <typename T>
+    struct then_set_value
+    {
+        using type = ::beman::execution26::set_value_t(T);
+    };
+    template <>
+    struct then_set_value<void>
+    {
+        using type = ::beman::execution26::set_value_t();
+    };
+
+    template <typename, typename, typename Completion>
+    struct then_transform
+    {
+        using type = Completion;
+    };
+
+    template <typename Fun, typename Replace>
+    struct then_transform_t
+    {
+        template <typename Completion>
+        using transform = typename
+        ::beman::execution26::detail::then_transform<Fun, Replace, Completion>
+        ::type;
+    };
+
+    template <typename Fun, typename Completion, typename... T>
+    struct then_transform<Fun, Completion, Completion(T...)>
+    {
+        using type = typename ::beman::execution26::detail::then_set_value<
+            ::beman::execution26::detail::call_result_t<Fun, T...>
+            >::type;
+    };
+
+    template <typename Completion, typename Fun, typename Sender, typename Env>
+    struct completion_signatures_for_impl<
+        ::beman::execution26::detail::basic_sender<
+            ::beman::execution26::detail::then_t<Completion>,
+            Fun,
+            Sender
+            >,
+        Env
+        >
+    {
+        using type = ::beman::execution26::detail::meta::unique<
+            ::beman::execution26::detail::meta::transform<
+                ::beman::execution26::detail::then_transform_t<Fun, Completion>::template transform,
+                ::beman::execution26::completion_signatures_of_t<Sender, Env>
+            >
+        >;
+    };
+}
+
+namespace beman::execution26
+{
+    using then_t = ::beman::execution26::detail::then_t<::beman::execution26::set_value_t>;
+    using upon_error_t = ::beman::execution26::detail::then_t<::beman::execution26::set_error_t>;
+    using upon_stopped_t = ::beman::execution26::detail::then_t<::beman::execution26::set_stopped_t>;
+
+    inline constexpr ::beman::execution26::then_t then{};
+    inline constexpr ::beman::execution26::upon_error_t upon_error{};
+    inline constexpr ::beman::execution26::upon_stopped_t upon_stopped{};
+}
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/src/beman/execution26/CMakeLists.txt b/src/beman/execution26/CMakeLists.txt
index f34f21b6..6e9df6c2 100644
--- a/src/beman/execution26/CMakeLists.txt
+++ b/src/beman/execution26/CMakeLists.txt
@@ -84,6 +84,7 @@ target_sources(${TARGET_LIBRARY}
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/meta_contains.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/meta_filter.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/meta_prepend.hpp
+    ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/meta_transform.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/meta_unique.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/movable_value.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/never_stop_token.hpp
@@ -123,6 +124,7 @@ target_sources(${TARGET_LIBRARY}
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/stoppable_token.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/sync_wait.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/tag_of_t.hpp
+    ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/then.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/transform_sender.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/type_list.hpp
     ${PROJECT_SOURCE_DIR}/include/beman/execution26/detail/unstoppable_token.hpp
diff --git a/src/beman/execution26/tests/CMakeLists.txt b/src/beman/execution26/tests/CMakeLists.txt
index b422c4f0..f5a291da 100644
--- a/src/beman/execution26/tests/CMakeLists.txt
+++ b/src/beman/execution26/tests/CMakeLists.txt
@@ -2,6 +2,9 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 list(APPEND execution_tests
+    exec-then.pass
+    exec-just.pass
+    meta-transform.pass
     exec-read-env.pass
     exec-get-delegation-scheduler.pass
     exec-snd-apply.pass
@@ -10,7 +13,6 @@ list(APPEND execution_tests
     exec-into-variant.pass
     exec-run-loop-types.pass
     exec-run-loop-general.pass
-    exec-just.pass
     exec-snd-expos.pass
     exec-recv-concepts.pass
     forward-like.pass
diff --git a/src/beman/execution26/tests/exec-just.pass.cpp b/src/beman/execution26/tests/exec-just.pass.cpp
index fabbba5e..876adae1 100644
--- a/src/beman/execution26/tests/exec-just.pass.cpp
+++ b/src/beman/execution26/tests/exec-just.pass.cpp
@@ -181,4 +181,8 @@ auto main() -> int
 {
     test_just_constraints();
     test_just();
+    using type = test_detail::call_result_t<test_std::get_completion_signatures_t,
+        decltype(test_std::just()), test_std::empty_env>;
+
+    static_assert(std::same_as<test_std::completion_signatures<test_std::set_value_t()>, type>);
 }
diff --git a/src/beman/execution26/tests/exec-then.pass.cpp b/src/beman/execution26/tests/exec-then.pass.cpp
new file mode 100644
index 00000000..9564234f
--- /dev/null
+++ b/src/beman/execution26/tests/exec-then.pass.cpp
@@ -0,0 +1,182 @@
+// src/beman/execution26/tests/exec-then.pass.cpp                     -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution26/detail/then.hpp>
+
+#include <beman/execution26/detail/completion_signatures_of_t.hpp>
+#include <beman/execution26/detail/connect.hpp>
+#include <beman/execution26/detail/just.hpp>
+#include <beman/execution26/detail/sender.hpp>
+#include <beman/execution26/detail/sender_in.hpp>
+#include <beman/execution26/detail/start.hpp>
+#include <beman/execution26/detail/sync_wait.hpp>
+#include <concepts>
+#include <test/execution.hpp>
+
+// ----------------------------------------------------------------------------
+
+namespace
+{
+    struct error { int value{}; };
+    struct non_sender {};
+
+    struct receiver
+    {
+        using receiver_concept = test_std::receiver_t;
+
+        auto set_error(auto&&) && noexcept -> void {}
+        auto set_stopped() && noexcept -> void {}
+        auto set_value(auto&&...) && noexcept -> void {}
+    };
+
+    template <typename... T>
+    struct sender
+    {
+        using sender_concept = test_std::sender_t;
+        using completion_signatures = test_std::completion_signatures<T...>;
+    };
+
+    template <bool Expect>
+    auto test_has(auto cpo, auto in_sender, auto fun) -> void
+    {
+        static_assert(test_std::receiver<receiver>);
+        static_assert(Expect == requires{ { cpo(in_sender, fun) } -> test_std::sender; });
+        if constexpr (Expect)
+        {
+            static_assert(requires{ cpo(fun); });
+            static_assert(requires{ in_sender | cpo(fun); });
+            static_assert(requires{ { in_sender | cpo(fun) } -> test_std::sender; });
+            static_assert(requires{ { in_sender | cpo(fun) | cpo([](auto&&...){}) } -> test_std::sender; });
+            auto sender{cpo(in_sender, fun)};
+            test::use(sender);
+            auto op{test_std::connect(sender, receiver{})};
+            test::use(op);
+            test_std::start(op);
+        }
+    }
+
+    template <typename... Completions>
+    auto test_then_type(auto sender)
+    {
+        static_assert(std::same_as<
+            test_std::completion_signatures<Completions...>,
+            test_std::completion_signatures_of_t<decltype(sender), test_std::empty_env>
+        >);
+    }
+
+    auto test_then_type() -> void
+    {
+        test_then_type< test_std::set_value_t()>(test_std::just(0) | test_std::then([](auto){}));
+        test_then_type< test_std::set_value_t(int)>(test_std::just() | test_std::then([]{ return 0; }));
+        test_then_type< test_std::set_error_t(int)>(test_std::just_error(0) | test_std::then([]{ return 0; }));
+        test_then_type< test_std::set_stopped_t()>(test_std::just_stopped() | test_std::then([]{ return 0; }));
+
+        test_then_type< test_std::set_value_t()>(test_std::just() | test_std::upon_error([]{ return 0; }));
+        test_then_type< test_std::set_value_t(int)>(test_std::just_error(error{})
+            | test_std::upon_error([](error){ return 0; }));
+        test_then_type< test_std::set_stopped_t()>(test_std::just_stopped() | test_std::upon_error([]{}));
+
+        test_then_type< test_std::set_value_t(int)>(test_std::just(0) | test_std::upon_stopped([]{}));
+        test_then_type< test_std::set_error_t(int)>(test_std::just_error(0) | test_std::upon_stopped([]{}));
+        test_then_type< test_std::set_value_t()>(test_std::just_stopped() | test_std::upon_stopped([]{}));
+    }
+
+    auto test_then_multi_type() -> void
+    {
+        static_assert(test_std::sender<sender<>>);
+        static_assert(test_std::sender_in<sender<>>);
+
+        test_then_type<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >(sender<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >());
+        test_then_type<
+                test_std::set_value_t(bool),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >(sender<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >() | test_std::then([](auto&&...){ return true; }));
+        test_then_type<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_value_t(bool),
+                test_std::set_stopped_t()
+            >(sender<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >() | test_std::upon_error([](error){ return true; }));
+        test_then_type<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_stopped_t()
+            >(sender<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >() | test_std::upon_error([](error){}));
+        test_then_type<
+                test_std::set_value_t(int),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_value_t()
+            >(sender<
+                test_std::set_value_t(int),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >() | test_std::upon_stopped([]{}));
+        test_then_type<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error)
+            >(sender<
+                test_std::set_value_t(),
+                test_std::set_value_t(int, int),
+                test_std::set_error_t(error),
+                test_std::set_stopped_t()
+            >() | test_std::upon_stopped([]{}));
+    }
+
+    auto test_then_value() -> void
+    {
+        assert(std::tuple{17} == *test_std::sync_wait(
+            test_std::just(5, 12) | test_std::then([](int a, int b){ return a + b; })
+        ));
+        assert(std::tuple{17} == test_std::sync_wait(
+            test_std::just_error(17) | test_std::upon_error([](int a){ return a; })
+        ));
+        assert(std::tuple{17} == test_std::sync_wait(
+            test_std::just_stopped() | test_std::upon_stopped([](){ return 17; })
+        ));
+    }
+}
+
+auto main() -> int
+{
+    static_assert(std::same_as<test_std::then_t const, decltype(test_std::then)>);
+    static_assert(std::same_as<test_std::upon_error_t const, decltype(test_std::upon_error)>);
+    static_assert(std::same_as<test_std::upon_stopped_t const, decltype(test_std::upon_stopped)>);
+
+    test_has<false>(test_std::then, non_sender{}, []{});
+    test_has<true>(test_std::then, test_std::just(), []{});
+    test_has<true>(test_std::then, test_std::just_error(error{3}), []{});
+    test_has<true>(test_std::then, test_std::just_stopped(), []{});
+
+    test_then_type();
+    test_then_multi_type();
+    test_then_value();
+}
diff --git a/src/beman/execution26/tests/meta-transform.pass.cpp b/src/beman/execution26/tests/meta-transform.pass.cpp
new file mode 100644
index 00000000..44957ef8
--- /dev/null
+++ b/src/beman/execution26/tests/meta-transform.pass.cpp
@@ -0,0 +1,47 @@
+// src/beman/execution26/tests/meta-transform.pass.cpp                -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution26/detail/meta_transform.hpp>
+#include <beman/execution26/detail/type_list.hpp>
+#include <test/execution.hpp>
+#include <concepts>
+#include <type_traits>
+
+// ----------------------------------------------------------------------------
+
+namespace
+{
+    template <typename>
+    struct foo {};
+    template <typename T>
+    using bar = foo<T>;
+
+    template <typename T>
+    struct baz { using type = foo<T>; };
+    template <typename T>
+    using baz_t = typename baz<T>::type;;
+}
+
+auto main() -> int
+{
+    static_assert(std::same_as<
+        test_detail::type_list<>,
+        test_detail::meta::transform<foo, test_detail::type_list<>>
+    >);
+    static_assert(std::same_as<
+        test_detail::type_list<foo<bool>, foo<char>>,
+        test_detail::meta::transform<foo, test_detail::type_list<bool, char>>
+    >);
+    static_assert(std::same_as<
+        test_detail::type_list<foo<bool>, foo<char>>,
+        test_detail::meta::transform<bar, test_detail::type_list<bool, char>>
+    >);
+    static_assert(std::same_as<
+        test_detail::type_list<foo<bool>, foo<char>>,
+        test_detail::meta::transform<baz_t, test_detail::type_list<bool, char>>
+    >);
+    static_assert(std::same_as<
+        test_detail::type_list<bool, char>,
+        test_detail::meta::transform<std::type_identity_t, test_detail::type_list<bool, char>>
+    >);
+}
\ No newline at end of file
diff --git a/src/beman/execution26/tests/meta-unique.pass.cpp b/src/beman/execution26/tests/meta-unique.pass.cpp
index bd7b8870..6d343a1d 100644
--- a/src/beman/execution26/tests/meta-unique.pass.cpp
+++ b/src/beman/execution26/tests/meta-unique.pass.cpp
@@ -43,11 +43,11 @@ auto main() -> int
         test_detail::meta::unique<type_list<bool, bool, char, char, double, double>>
         >);
     static_assert(std::same_as<
-        type_list<double, char, bool>,
+        type_list<bool, char, double>,
         test_detail::meta::unique<type_list<bool, char, double, char, bool>>
         >);
     static_assert(std::same_as<
-        type_list<double, bool, char>,
+        type_list<bool, char, double>,
         test_detail::meta::unique<type_list<bool, char, double, bool, char>>
         >);
 }
\ No newline at end of file