Folly Code Review · 70/89

folly::Try — Future 결과 wrapper

2026년 6월 7일 · Hawk · 3분 읽기

한 줄 요약: Try<T>는 정상값, 예외, 빈 상태 셋 중 하나를 담는다. Expected가 도메인 오류 표현이라면 Try는 예외 객체를 값으로 들고 다닐 때 쓴다. Futures 내부의 결과 슬롯.

#동기

Future/Task가 완료될 때 호출자는 두 가지 결과 중 하나를 받는다.

정상 결과 T.
비정상 — 예외 객체.

이 둘을 같은 슬롯에 담으려면 두 가지 해법이 있다.

변종 인터페이스 (Expected) — 도메인 오류 타입 E를 둔다. 그러나 임의 예외 타입을 그대로 받을 수 없다.
예외 객체를 값으로 보관 (Try) — std::exception_ptr 또는 folly::exception_wrapper로 임의 예외를 값 형태로.

Future/coroutine 결과 슬롯은 어떤 예외든 받아야 하므로 Try가 적합하다.

1
folly::Try<int> t = compute();
2
if (t.hasValue())      use(*t);
3
else if (t.hasException()) handle(t.exception());
4
else /* empty */       // moved-from 또는 미설정

세 상태 모델이다. Expected의 empty 상태와 같은 이유 — moved-from 같은 일시적 무효 상태가 필요해서.

#API

1
#include <folly/Try.h>
2

3
folly::Try<int> t1{42};                                  // value
4
folly::Try<int> t2{folly::make_exception_wrapper<std::runtime_error>("oops")};  // exception
5
folly::Try<int> t3;                                      // empty
6

7
// 상태 조회
8
t1.hasValue();       // true
9
t2.hasException();   // true
10
t3.hasValue();       // false
11

12
// 값 접근 — exception 상태면 throw
13
int v = t1.value();      // 42
14
int& vr = *t1;
15
int& vr2 = t1.value();
16

17
// 예외 접근
18
folly::exception_wrapper& ew = t2.exception();
19

20
// throw — exception 상태면 그 예외를 다시 throw, value 상태면 아무 일도 없음
21
t1.throwIfFailed();

Try<void> 도 일급. void 함수의 결과 슬롯에 쓴다.

#생성 방식

1
// 직접 값으로
2
folly::Try<int> a{10};
3
folly::Try<int> b{folly::in_place, 10};
4

5
// exception에서
6
folly::Try<int> c{folly::make_exception_wrapper<std::logic_error>("bad")};
7

8
// 람다 실행을 wrap — 정상이면 value, throw하면 exception 보관
9
auto t = folly::makeTryWith([&] { return riskyCompute(); });
10
// t는 hasValue 또는 hasException, throw가 호출자에게 전파되지 않음
11

12
// void 람다
13
auto tv = folly::makeTryWith([&] { riskyAction(); });   // Try<void>

makeTryWith가 가장 자주 쓴다. 예외를 catch해서 Try에 담는다는 한 줄 패턴.

#Futures와의 관계

1
// folly/futures/Future.h 약식
2
template <class T>
3
class Future {
4
 public:
5
  Try<T> getTry() &&;          // 결과 또는 예외를 Try로 추출
6
  T      get() &&;             // exception이면 throw
7

8
  template <class F>
9
  Future<R> thenTry(F&& fn);   // callback이 Try<T>를 받음
10
};

thenTry는 callback이 Try<T>를 받는다. value/exception을 같은 함수로 처리하고 싶을 때 쓴다.

1
compute()
2
  .thenTry([](folly::Try<int>&& t) {
3
    if (t.hasException()) {
4
      LOG(WARNING) << "compute failed: " << t.exception().what();
5
      return -1;
6
    }
7
    return *t * 2;
8
  });

thenValue(value만)와 thenError(exception만)가 합쳐진 형태가 thenTry.

코루틴에서도 비슷한 패턴:

1
auto t = co_await folly::coro::co_awaitTry(MaybeFails());
2
if (t.hasException()) { ... } else { use(*t); }

co_awaitTry가 Try<T>로 받는다. 예외 throw가 control flow에서 흔하면 이 형태가 가독성·성능 모두 낫다.

#내부 구조

1
// folly/Try.h 약식
2
template <class T>
3
class Try {
4
 public:
5
  enum class Contains { VALUE, EXCEPTION, NOTHING };
6

7
 private:
8
  Contains contains_ = Contains::NOTHING;
9
  union Storage {
10
    T                          value_;
11
    folly::exception_wrapper   ew_;
12
    Storage() {}
13
    ~Storage() {}
14
  };
15
  Storage storage_;
16

17
  void destroy() noexcept {
18
    if (contains_ == Contains::VALUE)     storage_.value_.~T();
19
    else if (contains_ == Contains::EXCEPTION) storage_.ew_.~exception_wrapper();
20
    contains_ = Contains::NOTHING;
21
  }
22
};

핵심은 두 가지.

discriminated union — value_ 또는 ew_ 둘 중 하나가 active. contains_가 어느 쪽인지 표시.
exception_wrapper — std::exception_ptr보다 풍부한 wrapper. 다음 절에서 본다.

#exception_wrapper — 왜 별도 타입인가

std::exception_ptr은 opaque 핸들이다. 예외 타입·메시지를 보려면 rethrow_exception + catch가 필요하다. log 한 줄 찍기에 무거운 비용.

folly::exception_wrapper는 wrapper 객체 자체에 type info, what() 캐시를 들고 다닌다.

1
folly::exception_wrapper ew = folly::make_exception_wrapper<std::runtime_error>("bad");
2

3
LOG(ERROR) << ew.what();         // throw 없이 message 추출
4
LOG(ERROR) << ew.class_name();   // 타입 이름
5

6
if (ew.is_compatible_with<std::runtime_error>()) {
7
  ew.with_exception([](const std::runtime_error& e) {
8
    // type-safe handle
9
  });
10
}

std::exception_ptr은 throw/catch 없이 정보를 못 꺼낸다. exception_wrapper는 메타정보를 wrapper 안에 직접 보유해 비용 없는 introspection이 가능하다.

이게 Futures가 Try<T> 안에서 예외를 들고 다닐 수 있는 기반이다. throw/catch 비용 없이 callback chain을 통과한다.

#Try

1
folly::Try<void> t = folly::makeTryWith([] { doIt(); });
2
if (t.hasException()) handle(t.exception());

Try<void>는 value()가 의미 없지만 hasValue() == true일 수는 있다(정상 완료). void async 결과를 같은 인터페이스로 다루기 위한 일급.

#std와의 비교

항목	std::exception_ptr	folly::exception_wrapper	folly::Try
역할	예외 캐리어	예외 캐리어 + 메타	결과 슬롯
message 접근	throw 후 catch	직접 `.what()`	`.exception().what()`
타입 introspection	안 됨	됨	`.exception().is_compatible_with<E>()`
결과 + 예외 동시	표현 안 됨	표현 안 됨	표현됨
표준	C++11	folly	folly

C++23에서도 std::expected가 T 또는 E (보통 enum) 두 갈래 모델만 표준화. 임의 예외를 값처럼 들고 다니는 표준 도구는 아직 없다.

#코드 리뷰 포인트

Try 만들고 즉시 *t — exception 상태에서 throw. 분기 필수.
callback이 Try 받는데 hasException 분기를 안 두면 silent swallow.
Try를 멤버로 보관 — moved-from(empty)인지 항상 확인해야.
exception_wrapper의 with_exception<E>(...)가 매치 안 되면 콜백이 실행되지 않는다 — fallback 필요.

#자주 보는 안티패턴

1
// 1. Try를 unwrap 강제
2
int v = t.value();   // empty 또는 exception이면 throw
3

4
// 2. exception_wrapper를 throw해서 다시 catch
5
try { t.exception().throw_exception(); }
6
catch (const std::runtime_error& e) { /* ... */ }
7
// → with_exception<std::runtime_error>(handler)로 throw 없이
8

9
// 3. Try<T>를 Expected처럼 사용 (도메인 오류 표현)
10
folly::Try<int> ParseInt(folly::StringPiece s);   // 의미가 어색하다
11
// 예외 throw가 정말 흔하면 Expected<int, ParseError> 가 옳다