fix visual studio errors

include/exec/sequence/marbles.hpp

@@ -100,9 +100,9 @@ namespace exec {
         return __lhs.__c_ == __rhs.__c_;
       }
 
-      friend std::string to_string(const __value_t& __self) noexcept {
-        using std::to_string;
-        return "'" + std::string{1, __self.__c_} + "'";
+      friend inline std::string to_string(const __value_t& __self) noexcept {
+        const char __result[4] = {'\'', __self.__c_, '\'', '\0'};
+        return __result;
       }
     };
 
@@ -122,41 +122,59 @@ namespace exec {
       operator marble_selector_t() const noexcept {
         return marble_selector_t::sequence_start;
       }
+      friend inline std::string to_string(sequence_start_t) noexcept {
+        return {"sequence_start"};
+      }
     };
     static constexpr inline sequence_start_t sequence_start;
 
     struct sequence_connect_t {
       operator marble_selector_t() const noexcept {
         return marble_selector_t::sequence_connect;
       }
+      friend inline std::string to_string(sequence_connect_t) noexcept {
+        return {"sequence_connect"};
+      }
     };
     static constexpr inline sequence_connect_t sequence_connect;
 
     struct sequence_end_t {
       operator marble_selector_t() const noexcept {
         return marble_selector_t::sequence_value;
       }
+      friend inline std::string to_string(sequence_end_t) noexcept {
+        return {"sequence_end"};
+      }
     };
     static constexpr inline sequence_end_t sequence_end;
 
     struct sequence_error_t {
       operator marble_selector_t() const noexcept {
         return marble_selector_t::sequence_error;
       }
+      friend inline std::string to_string(sequence_error_t) noexcept {
+        return {"sequence_error"};
+      }
     };
     static constexpr inline sequence_error_t sequence_error;
 
     struct sequence_stopped_t {
       operator marble_selector_t() const noexcept {
         return marble_selector_t::sequence_stopped;
       }
+      friend inline std::string to_string(sequence_stopped_t) noexcept {
+        return {"sequence_stopped"};
+      }
     };
     static constexpr inline sequence_stopped_t sequence_stopped;
 
     struct request_stop_t {
       operator marble_selector_t() const noexcept {
         return marble_selector_t::request_stop;
       }
+      friend inline std::string to_string(request_stop_t) noexcept {
+        return {"request_stop"};
+      }
     };
     static constexpr inline request_stop_t request_stop;
 
@@ -490,8 +508,11 @@ namespace exec {
             break;
           }
           default: {
-            long __consumed_in_default = 0;
-            if (__whole.begin() == __remaining.begin() || !!std::isspace(__remaining.front())) {
+            // use auto and math to derive the difference type
+            auto __consumed_in_default = __remaining.begin() - __remaining.begin();
+            if (
+              std::addressof(*__whole.begin()) == std::addressof(*__remaining.begin())
+              || !!std::isspace(__remaining.front())) {
               if (!!std::isspace(__remaining.front())) {
                 __consume_first(1);
                 ++__consumed_in_default;
@@ -508,7 +529,7 @@ namespace exec {
                 if (
                   __suffix_begin != __remaining.end() && __suffix_begin - __remaining.begin() > 0
                   && __all_digits) {
-                  long __to_consume = __suffix_begin - __remaining.begin();
+                  auto __to_consume = __suffix_begin - __remaining.begin();
                   long __duration = std::atol(__remaining.data());
                   if (std::ranges::equal(
                         __remaining.subspan(__to_consume, 3), __make_span("ms "_mstr))) {
@@ -800,6 +821,8 @@ namespace exec {
 
   } // namespace __marbles
 
+  using __value_t = __marbles::__value_t;
+
   using sequence_start_t = __marbles::sequence_start_t;
   static constexpr inline auto sequence_start = sequence_start_t{};
 
@@ -829,9 +852,6 @@ namespace exec {
 
   static constexpr inline auto record_marbles = record_marbles_t{};
 
-  namespace __marbles {
-
-  }
 } // namespace exec
 
 namespace stdexec {

include/exec/sequence/notification.hpp

@@ -22,6 +22,7 @@
 #include "stdexec/__detail/__config.hpp"
 #include "stdexec/__detail/__tuple.hpp"
 #include <concepts>
+#include <string>
 
 namespace exec {
   namespace __notification {
@@ -116,13 +117,13 @@ namespace exec {
       template <class _Receiver>
       void visit_receiver(_Receiver&& __receiver) noexcept {
         std::visit(
-          [&__receiver](auto&& __tuple) noexcept {
+          [&__receiver]<class _Tuple>(_Tuple&& __tuple) noexcept {
             __tuple.apply(
-              [&__receiver](auto __tag, auto&&... __args) noexcept {
+              [&__receiver]<class _Tag, class... _Args>(_Tag __tag, _Args&&... __args) noexcept {
                 __tag(
-                  static_cast<_Receiver&&>(__receiver), static_cast<decltype(__args)&&>(__args)...);
+                  static_cast<_Receiver&&>(__receiver), static_cast<_Args&&>(__args)...);
               },
-              static_cast<decltype(__tuple)&&>(__tuple));
+              static_cast<_Tuple&&>(__tuple));
           },
           static_cast<__notification_t&&>(__notification_));
       }
@@ -156,25 +157,31 @@ namespace exec {
       friend auto
         operator==(const notification_t& __lhs, const notification_t& __rhs) noexcept -> bool {
         return std::visit(
-          []<class _Lhs, class _Rhs>(const _Lhs& __lhs, const _Rhs& __rhs) noexcept {
+          []<class _Lhs, class _Rhs>(const _Lhs& __lhs, const _Rhs& __rhs) noexcept -> bool {
+            using __lhs_tag_t = notification_t::__tag_of_t<_Lhs>;
+            using __rhs_tag_t = notification_t::__tag_of_t<_Rhs>;
             if constexpr (
-              !std::same_as<__tag_of_t<_Lhs>, __tag_of_t<_Rhs>>
+              !std::same_as<__lhs_tag_t, __rhs_tag_t>
               || stdexec::__v<stdexec::__mapply<stdexec::__msize, _Lhs>>
                    != stdexec::__v<stdexec::__mapply<stdexec::__msize, _Rhs>>) {
               return false;
             } else {
               return __lhs.apply(
-                [&__rhs]<class _LTag, class... _LArgs>(_LTag, const _LArgs&... __l_args) {
-                  return __rhs.apply(
-                    [&]<class _RTag, class... _RArgs>(_RTag, const _RArgs&... __r_args) {
-                      if constexpr ((std::equality_comparable_with<const _LArgs&, const _RArgs&>
-                                     && ... && true)) {
-                        return ((__l_args == __r_args) && ... && true);
-                      } else {
-                        return false;
-                      }
-                    },
-                    __rhs);
+                [&__lhs,
+                 &__rhs]<class _LTag, class... _LArgs>(_LTag, const _LArgs&...) noexcept -> bool {
+                  return [&__lhs, &__rhs]<std::size_t... _Is>(__indices<_Is...>) {
+                    if constexpr ((std::equality_comparable_with<
+                                     const decltype(_Lhs::template __get<_Is+1>(__lhs))&,
+                                     const decltype(_Rhs::template __get<_Is+1>(__rhs))&
+                                   >
+                                   && ... && true)) {
+                      return (
+                        ((_Lhs::template __get<_Is+1>(__lhs)) == (_Rhs::template __get<_Is+1>(__rhs)))
+                        && ... && true);
+                    } else {
+                      return false;
+                    }
+                  }(__indices_for<_LArgs...>{});
                 },
                 __lhs);
             }

test/test_common/sequences.hpp

@@ -56,27 +56,6 @@ namespace exec::__sequence_sender {
   }
 } // namespace exec::__sequence_sender
 
-namespace exec::__marbles {
-  inline std::string to_string(sequence_start_t) noexcept {
-    return {"sequence_start"};
-  }
-  inline std::string to_string(sequence_connect_t) noexcept {
-    return {"sequence_connect"};
-  }
-  inline std::string to_string(sequence_end_t) noexcept {
-    return {"sequence_end"};
-  }
-  inline std::string to_string(sequence_error_t) noexcept {
-    return {"sequence_error"};
-  }
-  inline std::string to_string(sequence_stopped_t) noexcept {
-    return {"sequence_stopped"};
-  }
-  inline std::string to_string(request_stop_t) noexcept {
-    return {"request_stop"};
-  }
-} // namespace exec::__marbles
-
 namespace Catch {
   template <class _Clock, class _Duration>
   struct StringMaker<std::chrono::time_point<_Clock, _Duration>> {