folly::Future thenValue·thenError·thenTry — continuation 체인 분석

1
// 옛 API — 시그니처로 분기
2
f.then([](int x) { return x + 1; });           // value
3
f.then([](Try<int> t) { return *t + 1; });     // try
4
f.then([](int x) { return makeFuture(x); });   // future of future

1
// 정상값만 — 예외는 그대로 전파
2
f.thenValue([](int x) -> R { return f(x); });
3

4
// 예외만 — 정상값은 그대로 전파
5
f.thenError(folly::tag_t<MyError>{}, [](MyError const& e) -> int {
6
  return -1;
7
});
8

9
// 둘 다 — Try<T>로 통합
10
f.thenTry([](Try<int> t) -> R {
11
  if (t.hasException()) return R::error();
12
  return process(*t);
13
});

1
folly::SemiFuture<int> compute();
2

3
auto sf = compute()
4
  .deferValue([](int x) { return x + 1; })       // int → int
5
  .deferValue([](int x) {
6
    return folly::makeSemiFuture(x * 2);           // int → SemiFuture<int>
7
  })
8
  .deferValue([](int x) { return std::to_string(x); }); // int → string

1
// folly/futures/Future.h (개념)
2
template <class F>
3
auto Future<T>::thenValue(F&& fn) && {
4
  using R = std::invoke_result_t<F, T>;
5
  if constexpr (isSemiFuture<R>) {
6
    // flatten
7
    return this->then([fn = std::move(fn)](Try<T> t) -> SemiFuture<inner_t<R>> {
8
      return fn(*std::move(t));
9
    });
10
  } else {
11
    // wrap
12
    return ...;
13
  }
14
}

1
auto sf = fetch(url)
2
  .deferError(folly::tag_t<TimeoutError>{}, [](auto const&) {
3
    return defaultResponse();
4
  })
5
  .deferError(folly::tag_t<NetworkError>{}, [](auto const& e) {
6
    LOG(ERROR) << "network: " << e.what();
7
    throw;   // 재던지기
8
  });

1
.deferError(folly::tag_t<std::exception>{}, [](auto const& e) {
2
  LOG(ERROR) << "fallback: " << e.what();
3
  return Response::error();
4
});

1
fetch(url).deferValue(parse).thenTry([](folly::Try<Parsed> t) {
2
  if (t.hasException()) {
3
    metrics->errors.inc();
4
    return Result::fail(t.exception());
5
  }
6
  metrics->success.inc();
7
  return Result::ok(*std::move(t));
8
});

1
// 옛 API — 사용 금지
2
f.then([](int x) { return x + 1; });
3
f.then([](Try<int> t) { ... });

1
// folly/futures/detail/Core.h (요약)
2
template <class T>
3
void Core::setCallback(Callback callback, Executor::KeepAlive<> e) {
4
  // executor 등록
5
  setExecutor(std::move(e));
6

7
  // FSM 전이
8
  State expected = State::Start;
9
  if (state_.compare_exchange_strong(expected, State::OnlyCallback)) {
10
    callback_ = std::move(callback);
11
    return;
12
  }
13
  // 이미 result 도착
14
  expected = State::OnlyResult;
15
  if (state_.compare_exchange_strong(expected, State::Done)) {
16
    executor_->add([cb = std::move(callback), r = std::move(result_)]() mutable {
17
      cb(std::move(r));
18
    });
19
    return;
20
  }
21
}

1
// std::future — continuation 없음
2
std::future<int> f = std::async(...);
3
int v = f.get();
4
int r = process(v);   // 동기 처리만 가능
5

6
// std::expected (C++23) — 동기 monadic
7
std::expected<int, Err> e = compute();
8
auto r = e.and_then([](int x) { return std::expected<int, Err>{x + 1}; })
9
          .or_else([](Err e) { return std::expected<int, Err>{0}; });
10

11
// folly::Future — async monadic
12
folly::Future<int> f = ...;
13
auto r = std::move(f)
14
  .thenValue([](int x) { return x + 1; })   // ≈ and_then
15
  .thenError(folly::tag_t<Err>{}, [](Err) { return 0; });   // ≈ or_else

1
// 1. .then 사용
2
f.then([](int x) { return x + 1; });   // deprecated
3

4
// 2. thenError 순서 잘못
5
f.thenError(folly::tag_t<std::exception>{}, [](auto&) { return 0; })
6
 .thenError(folly::tag_t<MyError>{}, [](auto&) { return 1; });
7
// MyError가 std::exception을 상속하면 위에서 catch됨 — 두 번째 핸들러 도달 불가
8

9
// 3. value continuation 안에서 throw — 명시적이 더 낫다
10
f.thenValue([](int x) {
11
  if (x < 0) throw std::runtime_error("neg");
12
  return x;
13
});
14
// 차라리:
15
f.thenTry([](Try<int> t) -> Try<int> {
16
  if (*t < 0) return Try<int>(make_exception_wrapper<std::runtime_error>("neg"));
17
  return t;
18
});
19

20
// 4. thenError에서 다른 타입 반환
21
f.thenError(folly::tag_t<MyError>{}, [](auto&) {
22
  return "fallback";   // 원래 Future<int>인데 string 반환 — 컴파일 에러
23
});