template <class T, class E>
struct Result : public Either<T, E> {

    template <class V>
    Result(V&& v) : Either<T, E>(std::forward<V>(v)) {
    }
    template <class V>
    Result(const V& v) : Either<T, E>(v) {
    }

    auto Ok() const noexcept -> bool {
        return this->template Is<T>();
    }

    auto Unwrap() -> T& {
        try {
            return this->template As<T>();
        } catch (...) {
            throw this->template As<E>();
        }
    }

    auto Err() -> E {
        return this->template As<E>();
    }

    auto operator!() -> T& {
        return Unwrap();
    }
};


auto Res() -> monad::Result<monad::Unit, err::RuntimeError> {
    return err::RuntimeError("LOL");
}

auto Throws() -> void {
    !Res();
}

#include <string>
#include <fmt/format.h>

template<typename F>
struct Scope_exit {
  F f;
  Scope_exit(F f): f(std::move(f)) {}
  ~Scope_exit() { f(); }
};

auto make_string() {
  std::string result;

  Scope_exit guard = [&] {
    fmt::println("About to return '{}'", result);
  };

  for (int i = 0; i < 20; i++) {
    result += std::to_string(i);
  }

  return result;
}

int main() {
  auto s = make_string();
}

$ # Either behavior is legal of a C++ compiler
$ g++ a.cpp -lfmt -o a && ./a
About to return '012345678910111213141516171819'
$ g++ a.cpp -lfmt -o a -fno-elide-constructors && ./a
About to return ''

auto(*foo)(size_t)->void* {
    malloc  //
};

&*iovecs_.begin()

using T = std::iter_value_t<decltype(iovecs_.begin())>;
if constexpr(std::is_same_v<std::vector<T>, decltype(iovecs_)>) {
auto* ptr =reinterpret_cast<T*>(iovecs_.begin());
}

sudo ln /usr/bin/clang /usr/bin/gcc

struct Refcount_str: private std::runtime_error {
  using std::runtime_error::runtime_error;
  using std::runtime_error::operator=;
  ~Refcount_str() override = default;

  const char* c_str() const noexcept {
    return what();
  }

  char operator[] (std::ptrdiff_t i) const noexcept {
    return what()[i];
  }
};

auto mymalloc(std::size_t sz) -> void* {
  return ::operator new(sz, std::nothrow);
}