234.md

<details open><summary>Info</summary><p>

* **Did you know about function-try-block and that exceptions caught inside that block are implicitly rethrown?**

  * http://eel.is/c++draft/except.pre#nt:function-try-block

</p></details><details open><summary>Example</summary><p>

```cpp
struct foo {
  foo() { throw 0; }
};

struct bar {
  bar() try : foo_{} {
    // constructor body
  }
  catch (...)
  {
    // exceptions from the initializer list are caught here
    // but also re-thrown after this block (unless the program is aborted)
  }

private:
  foo foo_;
};

int main() try {
  bar b{};
}
catch(...) {
  // okay, exception cought here!
}
```

> https://godbolt.org/z/Y4efK573f

</p></details><details open><summary>Puzzle</summary><p>

* **Can you implement `foo`'s constructor which initializes `Ts...` and sets `exception` to true if any exception is thrown and rethrows it?**

```cpp
template<class TException>
struct ctor_except {
  ctor_except() { throw TException{}; }
};

template<class... Ts>
struct foo : Ts... {
  explicit(true) foo(bool& exception); // TODO
};

int main() {
  using namespace boost::ut;

  "function-try-block"_test = [] {
    bool exception{false};
    struct bar { };

    should("not set exception with empty list") = [=] {
      expect(nothrow([&]{ foo<>{mut(exception)}; }) and not exception);
    };

    should("not set exception with non-throwing types") = [=] {
      expect(nothrow([&]{ foo<bar>{mut(exception)}; }) and not exception);
    };

    should("catch exception if thrown from within the constructor") = [=] {
      expect(throws<int>([&]{ foo<ctor_except<int>>{mut(exception)}; }) and exception);
    };

    should("catch exception if thrown from within the constructor with muliple types") = [=] {
      expect(throws<int>([&]{ foo<bar, ctor_except<int>>{mut(exception)}; }) and exception);
    };
  };
}
```

> https://godbolt.org/z/s3MzE8xM9

</p></details><details><summary>Solutions</summary><p>

```cpp
template<class... Ts>
struct foo : Ts... {
  explicit(true) foo (bool& exception) try : Ts{}... {
  } catch (...) {
    exception = true;
  }
};
```

> https://godbolt.org/z/8Yxr7WbsM

```cpp
template<class... Ts>
struct foo : Ts... {
  explicit(true) foo(bool& exception) try : Ts()... {
      exception = false;
  } catch(...) {
      exception = true;
  }
};
```

> https://godbolt.org/z/dnhcjsYjK