folly::Try vs Expected 선택 기준

1
              | 도메인 오류 명시 | 임의 예외 캐리어
2
─────────────|──────────────────|──────────────────
3
함수 반환     |   Expected       |  Try (드물게 OK)
4
Future 결과   |   Future<E>가    |   Try (항상)
5
              |   드물게 가능      |
6
Variant 슬롯  |   variant        |   Try

1
// 도메인 함수 — Expected
2
folly::Expected<int, ParseError> ParseInt(folly::StringPiece s);
3

4
// 비동기 wrapping — Future<int>로 노출
5
folly::SemiFuture<int> ParseIntAsync(std::string s);
6

7
// Future가 throw할 때 호출자가 Try로 받음
8
folly::SemiFuture<int> f = ParseIntAsync("42");
9
auto t = std::move(f).getTry();   // Try<int>
10

11
if (t.hasValue()) use(*t);
12
else {
13
  // 어떤 예외든 가능 — ParseError가 throw됐을 수도, network 예외일 수도
14
  if (t.exception().is_compatible_with<ParseException>()) { ... }
15
  else if (t.exception().is_compatible_with<std::system_error>()) { ... }
16
}

1
folly::SemiFuture<int> ToFuture(folly::Expected<int, ParseError> e) {
2
  if (e) return folly::makeSemiFuture<int>(*e);
3
  return folly::makeSemiFuture<int>(
4
    folly::make_exception_wrapper<ParseException>(e.error()));
5
}

1
folly::Expected<int, ParseError> FromTry(folly::Try<int>&& t) {
2
  if (t.hasValue()) return *t;
3
  if (t.exception().is_compatible_with<ParseException>()) {
4
    return folly::makeUnexpected(
5
      t.exception().get_exception<ParseException>()->error());
6
  }
7
  // 임의 예외 — 도메인 enum으로 표현 불가
8
  return folly::makeUnexpected(ParseError::Unknown);
9
}

1
// 1. 도메인 함수가 Try 반환
2
folly::Try<int> ParseInt(folly::StringPiece s);
3
// → Expected<int, ParseError>. Try는 비동기 슬롯이지 도메인 시그니처가 아님
4

5
// 2. Future가 Expected를 노출
6
folly::Future<folly::Expected<int, ParseError>> compute();
7
// → 이중 분기. Future가 Expected를 들고 다닐 이유 없음.
8
//   compute()가 throw하거나 Future<int>로 충분.
9

10
// 3. Try를 함수 인자로
11
void process(folly::Try<int> t);
12
// → 의미가 어색. 호출자가 분기해서 정상값/오류 path로 가는 게 자연스러움.
13

14
// 4. Expected의 E가 std::exception_ptr
15
folly::Expected<int, std::exception_ptr> Compute();
16
// → Try가 적합. Expected는 도메인 enum/struct를 위함.

1
// 도메인 함수 (sync)
2
Expected<User, AuthError> Authenticate(Token t);
3

4
// 비동기 wrapping
5
SemiFuture<User> AuthenticateAsync(Token t);
6
// 내부: Authenticate() → Expected → throw → Future
7

8
// 호출자
9
SemiFuture<User> f = AuthenticateAsync(token);
10
auto t = std::move(f).getTry();   // Try<User>
11
if (t.hasException<AuthException>()) { ... }

1
// 1. Try와 Expected를 같은 함수에서 혼용
2
folly::Try<folly::Expected<int, Error>> compute();
3
// → 의미 없는 이중 wrapping
4

5
// 2. Future<Expected<T, E>>
6
// → Future가 throw하거나 Future<T>면 됨
7

8
// 3. 도메인 코드 전체를 Try로
9
folly::Try<int> Step1();
10
folly::Try<int> Step2();
11
// → Expected가 의도를 더 명확히
12

13
// 4. Expected의 E에 string
14
folly::Expected<int, std::string> Foo();
15
// → enum/struct로 type-safe하게. string은 메시지지 타입이 아님.