grpc 1.68.1 → 1.71.0

data/src/core/lib/promise/for_each.h

@@ -58,6 +58,13 @@ struct Done<StatusFlag> {
   }
 };
 
+template <>
+struct Done<Success> {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static StatusFlag Make(bool cancelled) {
+    return StatusFlag(!cancelled);
+  }
+};
+
 template <typename T, typename SfinaeVoid = void>
 struct NextValueTraits;
 
@@ -83,11 +90,11 @@ struct NextValueTraits<T, absl::void_t<typename T::value_type>> {
 };
 
 template <typename T>
-struct NextValueTraits<ValueOrFailure<absl::optional<T>>> {
+struct NextValueTraits<ValueOrFailure<std::optional<T>>> {
   using Value = T;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static NextValueType Type(
-      const ValueOrFailure<absl::optional<T>>& t) {
+      const ValueOrFailure<std::optional<T>>& t) {
     if (t.ok()) {
       if (t.value().has_value()) return NextValueType::kValue;
       return NextValueType::kEndOfStream;
@@ -96,7 +103,7 @@ struct NextValueTraits<ValueOrFailure<absl::optional<T>>> {
   }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Value&& TakeValue(
-      ValueOrFailure<absl::optional<T>>& t) {
+      ValueOrFailure<std::optional<T>>& t) {
     return std::move(**t);
   }
 };
@@ -111,10 +118,12 @@ class ForEach {
   using ActionFactory =
       promise_detail::RepeatedPromiseFactory<ReaderResultValue, Action>;
   using ActionPromise = typename ActionFactory::Promise;
+  using ActionResult =
+      typename PollTraits<decltype(std::declval<ActionPromise>()())>::Type;
 
  public:
-  using Result =
-      typename PollTraits<decltype(std::declval<ActionPromise>()())>::Type;
+  using Result = decltype(Done<ActionResult>::Make(false));
+
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ForEach(Reader reader, Action action,
                                                DebugLocation whence = {})
       : reader_(std::move(reader)),

data/src/core/lib/promise/if.h

@@ -19,9 +19,9 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include "absl/status/statusor.h"
-#include "absl/types/variant.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
@@ -31,6 +31,47 @@ namespace grpc_core {
 
 namespace promise_detail {
 
+// If promise combinator.
+//
+// If(C condition, T if_true, F if_false)
+//
+// Takes exactly 3 inputs
+//
+// The first input C can be one of the following
+// 1. A bool variable or constant.
+// 2. A promise that returns Poll<bool>
+// 3. A promise factory that returns a promise that returns Poll<bool>
+// 4. A promise that returns Poll<absl::StatusOr<bool>>
+// 5. A promise factory that returns a promise that returns
+//    Poll<absl::StatusOr<bool>>
+//
+// The second and third inputs can be one of the following
+// 1. Promise
+// 2. Promise Factory
+// The second and third promises must have the same return type.
+//
+// The If combinator works in the following way
+// 1. It processes the first input first. If the first input is a promise or a
+// promise factory, the promise is executed. The return value of this execution
+// could either be Poll<bool> or Poll<absl::StatusOr<bool>> . If the first input
+// is a bool, it is taken as it is.
+// 2. If the first promise returns Pending{} , the second and third promises are
+// not executed.
+// 3. If the promise returns any failure status , the second and third promises
+// are not executed.
+// 4. If the return value of the first promise is equivalent to true, the
+// combinator executes the second promise (if_true).
+// 5. If the return value of the first promise is equivalent to false, the
+// combinator executes the third promise (if_false).
+//
+// Both the condition and the if_true/if_false promises will be executed
+// serially on the same thread.
+//
+// If first input is a constant, it's guaranteed that one of the promise
+// factories if_true or if_false will be evaluated before returning from this
+// function. This makes it safe to capture lambda arguments in the promise
+// factory by reference.
+
 template <typename CallPoll, typename T, typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline typename CallPoll::PollResult
 ChooseIf(CallPoll call_poll, bool result, T* if_true, F* if_false) {
@@ -58,12 +99,14 @@ ChooseIf(CallPoll call_poll, absl::StatusOr<bool> result, T* if_true,
   }
 }
 
+}  // namespace promise_detail
+
 template <typename C, typename T, typename F>
 class If {
  private:
   using TrueFactory = promise_detail::OncePromiseFactory<void, T>;
   using FalseFactory = promise_detail::OncePromiseFactory<void, F>;
-  using ConditionPromise = PromiseLike<C>;
+  using ConditionPromise = promise_detail::PromiseLike<C>;
   using TruePromise = typename TrueFactory::Promise;
   using FalsePromise = typename FalseFactory::Promise;
   using Result =
@@ -76,7 +119,7 @@ class If {
                           FalseFactory(std::move(if_false))}) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
-    return absl::visit(CallPoll<false>{this}, state_);
+    return std::visit(CallPoll<false>{this}, state_);
   }
 
  private:
@@ -85,7 +128,7 @@ class If {
     TrueFactory if_true;
     FalseFactory if_false;
   };
-  using State = absl::variant<Evaluating, TruePromise, FalsePromise>;
+  using State = std::variant<Evaluating, TruePromise, FalsePromise>;
   State state_;
 
   template <bool kSetState>
@@ -188,23 +231,8 @@ class If<bool, T, F> {
 #endif
 };
 
-}  // namespace promise_detail
-
-// If promise combinator.
-// Takes 3 promise factories, and evaluates the first.
-// If it returns failure, returns failure for the entire combinator.
-// If it returns true, evaluates the second promise.
-// If it returns false, evaluates the third promise.
-// If C is a constant, it's guaranteed that one of the promise factories
-// if_true or if_false will be evaluated before returning from this function.
-// This makes it safe to capture lambda arguments in the promise factory by
-// reference.
 template <typename C, typename T, typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::If<C, T, F> If(
-    C condition, T if_true, F if_false) {
-  return promise_detail::If<C, T, F>(std::move(condition), std::move(if_true),
-                                     std::move(if_false));
-}
+If(C, T, F) -> If<C, T, F>;
 
 }  // namespace grpc_core
 

data/src/core/lib/promise/interceptor_list.h

@@ -20,6 +20,7 @@
 
 #include <algorithm>
 #include <new>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -27,7 +28,6 @@
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
@@ -58,7 +58,7 @@ class InterceptorList {
     // Poll a promise constructed at memory.
     // Resolves to an optional<T> -- if nullopt it means terminate the chain and
     // resolve.
-    virtual Poll<absl::optional<T>> PollOnce(void* memory) = 0;
+    virtual Poll<std::optional<T>> PollOnce(void* memory) = 0;
     virtual ~Map() = default;
 
     // Update the next pointer stored with this map.
@@ -83,7 +83,7 @@ class InterceptorList {
   // The result of Run: a promise that will execute the entire chain.
   class RunPromise {
    public:
-    RunPromise(size_t memory_required, Map** factory, absl::optional<T> value) {
+    RunPromise(size_t memory_required, Map** factory, std::optional<T> value) {
       if (!value.has_value() || *factory == nullptr) {
         GRPC_TRACE_VLOG(promise_primitives, 2)
             << "InterceptorList::RunPromise[" << this << "]: create immediate";
@@ -133,14 +133,14 @@ class InterceptorList {
 
     RunPromise& operator=(RunPromise&& other) noexcept = delete;
 
-    Poll<absl::optional<T>> operator()() {
+    Poll<std::optional<T>> operator()() {
       GRPC_TRACE_VLOG(promise_primitives, 2)
           << "InterceptorList::RunPromise[" << this << "]: " << DebugString();
       if (is_immediately_resolved_) return std::move(result_);
       while (true) {
         if (*async_resolution_.first_factory == nullptr) {
           // Cancelled whilst polling
-          return absl::nullopt;
+          return std::nullopt;
         }
         auto r = async_resolution_.current_factory->PollOnce(
             async_resolution_.space.get());
@@ -194,7 +194,7 @@ class InterceptorList {
     };
     union {
       AsyncResolution async_resolution_;
-      absl::optional<T> result_;
+      std::optional<T> result_;
     };
     // If true, the result_ union is valid, otherwise async_resolution_ is.
     // Indicates whether the promise resolved immediately at construction or if
@@ -207,7 +207,7 @@ class InterceptorList {
   InterceptorList& operator=(const InterceptorList&) = delete;
   ~InterceptorList() { DeleteFactories(); }
 
-  RunPromise Run(absl::optional<T> initial_value) {
+  RunPromise Run(std::optional<T> initial_value) {
     return RunPromise(promise_memory_required_, &first_map_,
                       std::move(initial_value));
   }
@@ -263,8 +263,8 @@ class InterceptorList {
     void Destroy(void* memory) override {
       static_cast<Promise*>(memory)->~Promise();
     }
-    Poll<absl::optional<T>> PollOnce(void* memory) override {
-      return poll_cast<absl::optional<T>>((*static_cast<Promise*>(memory))());
+    Poll<std::optional<T>> PollOnce(void* memory) override {
+      return poll_cast<std::optional<T>>((*static_cast<Promise*>(memory))());
     }
 
    private:

data/src/core/lib/promise/latch.h

@@ -31,11 +31,19 @@
 
 namespace grpc_core {
 
-// Latch provides a single set waitable object.
-// Initially the Latch is unset.
-// It can be waited upon by the Wait method, which produces a Promise that
-// resolves when the Latch is Set to a value of type T.
-// Latches only work correctly within a single activity.
+// Latches only work correctly within a single activity or a single party. If
+// you need something that works across activities/parties refer to
+// inter_activity_latch.h
+//
+// Latch provides a single set waitable object. We use Latch when we want to
+// wait for a particular object to be set. This object would typically be set by
+// some promise getting resolved.
+//
+// Initially the value Latch is unset.
+//
+// We can wait for Latch to be set using either the Wait or WaitAndCopy method.
+// These two methods produce Promises that resolves when the Latch is value Set
+// to a value of type T.
 template <typename T>
 class Latch {
  public:
@@ -117,7 +125,7 @@ class Latch {
 
   // The value stored (if has_value_ is true), otherwise some random value, we
   // don't care.
-  // Why not absl::optional<>? Writing things this way lets us compress
+  // Why not std::optional<>? Writing things this way lets us compress
   // has_value_ with waiter_ and leads to some significant memory savings for
   // some scenarios.
   GPR_NO_UNIQUE_ADDRESS T value_;

data/src/core/lib/promise/loop.h

@@ -18,16 +18,59 @@
 #include <grpc/support/port_platform.h>
 
 #include <utility>
+#include <variant>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/types/variant.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/construct_destruct.h"
 
 namespace grpc_core {
 
+// A Loop combinator
+//
+// Input:
+//
+// 1. A Loop combinator takes as input only one promise factory.
+// 2. This input promise factory should have a return type of either
+//    a.  LoopCtl<T> which is an alias for std::variant<Continue, T>
+//    b.  Or Poll<LoopCtl<T>>
+//
+// Running of the Loop combinator:
+//
+// 1. The input promise is guranteed to run at least once when the combinator
+//    is invoked.
+// 2. The Loop combinators execution will keep running input promise for
+//    as long as the input promise returns the Continue() object.
+// 3. The Loop breaks if
+//    a.  the input promise returns T.
+//    b.  the input promise returns Pending{}.
+//
+// The execution of multiple iterations of the input
+// promise happen on the same thread.
+//
+// Return:
+//
+// The Loop combinator when executed will return Poll<T>.
+//
+// Example:
+//
+// {
+//   std::string execution_order;
+//   int i = 0;
+//   Poll<int> retval = Loop([&execution_order, &i]() -> LoopCtl<int> {
+//     absl::StrAppend(&execution_order, i);
+//     i++;
+//     if (i < 5) return Continue();
+//     return i;
+//   })();
+//   EXPECT_TRUE(retval.ready());
+//   EXPECT_EQ(retval.value(), 5);
+//   EXPECT_STREQ(execution_order.c_str(), "01234");
+// }
+
 // Special type - signals to loop to take another iteration, instead of
 // finishing
 struct Continue {};
@@ -35,7 +78,7 @@ struct Continue {};
 // Result of polling a loop promise - either Continue looping, or return a value
 // T
 template <typename T>
-using LoopCtl = absl::variant<Continue, T>;
+using LoopCtl = std::variant<Continue, T>;
 
 namespace promise_detail {
 
@@ -58,8 +101,8 @@ struct LoopTraits<absl::StatusOr<LoopCtl<T>>> {
       absl::StatusOr<LoopCtl<T>> value) {
     if (!value.ok()) return value.status();
     auto& inner = *value;
-    if (absl::holds_alternative<Continue>(inner)) return Continue{};
-    return absl::get<T>(std::move(inner));
+    if (std::holds_alternative<Continue>(inner)) return Continue{};
+    return std::get<T>(std::move(inner));
   }
 };
 
@@ -70,20 +113,24 @@ struct LoopTraits<absl::StatusOr<LoopCtl<absl::Status>>> {
       absl::StatusOr<LoopCtl<absl::Status>> value) {
     if (!value.ok()) return value.status();
     const auto& inner = *value;
-    if (absl::holds_alternative<Continue>(inner)) return Continue{};
-    return absl::get<absl::Status>(inner);
+    if (std::holds_alternative<Continue>(inner)) return Continue{};
+    return std::get<absl::Status>(inner);
   }
 };
 
+}  // namespace promise_detail
+
 template <typename F>
 class Loop {
  private:
+  static_assert(promise_detail::kIsRepeatedPromiseFactory<void, F>);
+
   using Factory = promise_detail::RepeatedPromiseFactory<void, F>;
   using PromiseType = decltype(std::declval<Factory>().Make());
   using PromiseResult = typename PromiseType::Result;
 
  public:
-  using Result = typename LoopTraits<PromiseResult>::Result;
+  using Result = typename promise_detail::LoopTraits<PromiseResult>::Result;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Loop(F f)
       : factory_(std::move(f)) {}
@@ -100,6 +147,8 @@ class Loop {
   Loop& operator=(const Loop& loop) = delete;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
+    GRPC_TRACE_LOG(promise_primitives, INFO)
+        << "loop[" << this << "] begin poll started=" << started_;
     if (!started_) {
       started_ = true;
       Construct(&promise_, factory_.Make());
@@ -111,16 +160,23 @@ class Loop {
       if (auto* p = promise_result.value_if_ready()) {
         //  - then if it's Continue, destroy the promise and recreate a new one
         //  from our factory.
-        auto lc = LoopTraits<PromiseResult>::ToLoopCtl(std::move(*p));
-        if (absl::holds_alternative<Continue>(lc)) {
+        auto lc =
+            promise_detail::LoopTraits<PromiseResult>::ToLoopCtl(std::move(*p));
+        if (std::holds_alternative<Continue>(lc)) {
+          GRPC_TRACE_LOG(promise_primitives, INFO)
+              << "loop[" << this << "] iteration complete, continue";
           Destruct(&promise_);
           Construct(&promise_, factory_.Make());
           continue;
         }
+        GRPC_TRACE_LOG(promise_primitives, INFO)
+            << "loop[" << this << "] iteration complete, return";
         //  - otherwise there's our result... return it out.
-        return absl::get<Result>(std::move(lc));
+        return std::get<Result>(std::move(lc));
       } else {
         // Otherwise the inner promise was pending, so we are pending.
+        GRPC_TRACE_LOG(promise_primitives, INFO)
+            << "loop[" << this << "] pending";
         return Pending();
       }
     }
@@ -134,15 +190,8 @@ class Loop {
   bool started_ = false;
 };
 
-}  // namespace promise_detail
-
-// Looping combinator.
-// Expects F returns LoopCtl<T> - if it's Continue, then run the loop again -
-// otherwise yield the returned value as the result of the loop.
 template <typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Loop<F> Loop(F f) {
-  return promise_detail::Loop<F>(std::move(f));
-}
+Loop(F) -> Loop<F>;
 
 }  // namespace grpc_core
 

data/src/core/lib/promise/map.h

@@ -19,8 +19,12 @@
 #include <stddef.h>
 
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -28,11 +32,82 @@ namespace grpc_core {
 
 namespace promise_detail {
 
-// Implementation of mapping combinator - use this via the free function below!
-// Promise is the type of promise to poll on, Fn is a function that takes the
-// result of Promise and maps it to some new type.
+template <typename Fn, typename Arg, typename SfinaeVoid = void>
+class WrappedFn;
+
+template <typename Fn, typename Arg>
+class WrappedFn<
+    Fn, Arg, std::enable_if_t<!std::is_void_v<std::invoke_result_t<Fn, Arg>>>> {
+ public:
+  using Result = RemoveCVRef<std::invoke_result_t<Fn, Arg>>;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit WrappedFn(Fn&& fn)
+      : fn_(std::move(fn)) {}
+  WrappedFn(const WrappedFn&) = delete;
+  WrappedFn& operator=(const WrappedFn&) = delete;
+  WrappedFn(WrappedFn&&) = default;
+  WrappedFn& operator=(WrappedFn&&) = default;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()(Arg&& arg) {
+    return fn_(std::forward<Arg>(arg));
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Fn fn_;
+};
+
+template <typename Fn, typename Arg>
+class WrappedFn<
+    Fn, Arg, std::enable_if_t<std::is_void_v<std::invoke_result_t<Fn, Arg>>>> {
+ public:
+  using Result = Empty;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit WrappedFn(Fn&& fn)
+      : fn_(std::move(fn)) {}
+  WrappedFn(const WrappedFn&) = delete;
+  WrappedFn& operator=(const WrappedFn&) = delete;
+  WrappedFn(WrappedFn&&) = default;
+  WrappedFn& operator=(WrappedFn&&) = default;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Empty operator()(Arg&& arg) {
+    fn_(std::forward<Arg>(arg));
+    return Empty{};
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Fn fn_;
+};
+
+template <typename PromiseResult, typename Fn0, typename Fn1>
+class FusedFns {
+  using InnerResult =
+      decltype(std::declval<Fn0>()(std::declval<PromiseResult>()));
+
+ public:
+  using Result = typename WrappedFn<Fn1, InnerResult>::Result;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION FusedFns(Fn0 fn0, Fn1 fn1)
+      : fn0_(std::move(fn0)), fn1_(std::move(fn1)) {}
+  FusedFns(const FusedFns&) = delete;
+  FusedFns& operator=(const FusedFns&) = delete;
+  FusedFns(FusedFns&&) = default;
+  FusedFns& operator=(FusedFns&&) = default;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()(PromiseResult arg) {
+    InnerResult inner_result = fn0_(std::move(arg));
+    return fn1_(std::move(inner_result));
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Fn0 fn0_;
+  GPR_NO_UNIQUE_ADDRESS WrappedFn<Fn1, InnerResult> fn1_;
+};
+
+}  // namespace promise_detail
+
+// Mapping combinator.
+// Takes a promise, and a synchronous function to mutate its result, and
+// returns a promise.
 template <typename Promise, typename Fn>
 class Map {
+  using PromiseType = promise_detail::PromiseLike<Promise>;
+
  public:
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Promise promise, Fn fn)
       : promise_(std::move(promise)), fn_(std::move(fn)) {}
@@ -44,9 +119,8 @@ class Map {
   // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
   Map& operator=(Map&& other) = default;
 
-  using PromiseResult = typename PromiseLike<Promise>::Result;
-  using Result =
-      RemoveCVRef<decltype(std::declval<Fn>()(std::declval<PromiseResult>()))>;
+  using PromiseResult = typename PromiseType::Result;
+  using Result = typename promise_detail::WrappedFn<Fn, PromiseResult>::Result;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
     Poll<PromiseResult> r = promise_();
@@ -57,20 +131,54 @@ class Map {
   }
 
  private:
-  PromiseLike<Promise> promise_;
-  Fn fn_;
+  template <typename SomeOtherPromise, typename SomeOtherFn>
+  friend class Map;
+
+  GPR_NO_UNIQUE_ADDRESS PromiseType promise_;
+  GPR_NO_UNIQUE_ADDRESS promise_detail::WrappedFn<Fn, PromiseResult> fn_;
 };
 
-}  // namespace promise_detail
+template <typename Promise, typename Fn0, typename Fn1>
+class Map<Map<Promise, Fn0>, Fn1> {
+  using InnerMapFn = decltype(std::declval<Map<Promise, Fn0>>().fn_);
+  using FusedFn =
+      promise_detail::FusedFns<typename Map<Promise, Fn0>::PromiseResult,
+                               InnerMapFn, Fn1>;
+  using PromiseType = typename Map<Promise, Fn0>::PromiseType;
+
+ public:
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Map<Promise, Fn0> map, Fn1 fn1)
+      : promise_(std::move(map.promise_)),
+        fn_(FusedFn(std::move(map.fn_), std::move(fn1))) {}
+
+  Map(const Map&) = delete;
+  Map& operator=(const Map&) = delete;
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
+  Map(Map&& other) = default;
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
+  Map& operator=(Map&& other) = default;
+
+  using PromiseResult = typename Map<Promise, Fn0>::PromiseResult;
+  using Result = typename FusedFn::Result;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
+    Poll<PromiseResult> r = promise_();
+    if (auto* p = r.value_if_ready()) {
+      return fn_(std::move(*p));
+    }
+    return Pending();
+  }
+
+ private:
+  template <typename SomeOtherPromise, typename SomeOtherFn>
+  friend class Map;
+
+  GPR_NO_UNIQUE_ADDRESS PromiseType promise_;
+  GPR_NO_UNIQUE_ADDRESS FusedFn fn_;
+};
 
-// Mapping combinator.
-// Takes a promise, and a synchronous function to mutate its result, and
-// returns a promise.
 template <typename Promise, typename Fn>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Map<Promise, Fn>
-Map(Promise promise, Fn fn) {
-  return promise_detail::Map<Promise, Fn>(std::move(promise), std::move(fn));
-}
+Map(Promise, Fn) -> Map<Promise, Fn>;
 
 // Maps a promise to a new promise that returns a tuple of the original result
 // and a bool indicating whether there was ever a Pending{} value observed from
@@ -79,13 +187,13 @@ template <typename Promise>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto CheckDelayed(Promise promise) {
   using P = promise_detail::PromiseLike<Promise>;
   return [delayed = false, promise = P(std::move(promise))]() mutable
-         -> Poll<std::tuple<typename P::Result, bool>> {
+             -> Poll<std::tuple<typename P::Result, bool>> {
     auto r = promise();
     if (r.pending()) {
       delayed = true;
       return Pending{};
     }
-    return std::make_tuple(std::move(r.value()), delayed);
+    return std::tuple(std::move(r.value()), delayed);
   };
 }
 
@@ -104,6 +212,45 @@ struct JustElem {
   }
 };
 
+namespace promise_detail {
+template <typename Fn>
+class MapError {
+ public:
+  explicit MapError(Fn fn) : fn_(std::move(fn)) {}
+  absl::Status operator()(absl::Status status) {
+    if (status.ok()) return status;
+    return fn_(std::move(status));
+  }
+  template <typename T>
+  absl::StatusOr<T> operator()(absl::StatusOr<T> status) {
+    if (status.ok()) return status;
+    return fn_(std::move(status.status()));
+  }
+
+ private:
+  Fn fn_;
+};
+}  // namespace promise_detail
+
+// Map status->better status in the case of errors
+template <typename Promise, typename Fn>
+auto MapErrors(Promise promise, Fn fn) {
+  return Map(std::move(promise), promise_detail::MapError<Fn>(std::move(fn)));
+}
+
+// Simple mapper to add a prefix to the message of an error
+template <typename Promise>
+auto AddErrorPrefix(absl::string_view prefix, Promise promise) {
+  return MapErrors(std::move(promise), [prefix](absl::Status status) {
+    absl::Status out(status.code(), absl::StrCat(prefix, status.message()));
+    status.ForEachPayload(
+        [&out](absl::string_view name, const absl::Cord& value) {
+          out.SetPayload(name, value);
+        });
+    return out;
+  });
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_MAP_H