GSL

At the time Herb made that comment GSL was documented as supporting XCode 12.5.1/13.2.1, GCC 10/11, Clang 11/12, and Visual Studio 2019/2022 using both MSVC/LLVM [0]. Even if MSVC had special support for GSL I'm a bit more skeptical that such support would extend to XCode, GCC, and Clang. [0]: https://github.com/microsoft/GSL/tree/99a29ce797c8337b8923f2...

For what it's worth, a GSL developer later reopened that GitHub issue and stated that they're going to look into fixing the UB. Sutter may have just been stating an assumption. https://github.com/microsoft/GSL/issues/786#issuecomment-513... > I'll raise this issue in the next internal GSL sync. I'd agree with y'all that this behavior: https://godbolt.org/z/4Tr1fe9xG is undesirable

The C++ core guideline support library has it. https://github.com/microsoft/GSL/blob/main/docs/headers.md#u... What do you mean by move-out unique_ptr? That the not_null ptr type would ne null after it's been moved? In that case that's just a plain usage error, same as how you could memset it to null.

I haven't read much from Bjarne but this is refreshingly self-aware and paints a hopeful path to standardize around "the good parts" of C++. As a C++ newbie I just don't understand the recommended path I'm supposed to follow, though. It seems to be a mix of "a book of guidelines" and "a package that shows you how you should be using those guidelines via implementation of their principles". After some digging it looks like the guidebook is the "C++ Core Guidelines": https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines And I'm supposed to read that and then: > use parts of the standard library and add a tiny library to make use of the guidelines convenient and efficient (the Guidelines Support Library, GSL). Which seems to be this (at least Microsoft's implementation): https://github.com/microsoft/GSL And I'm left wondering, is this

This is awesome. Could they reconcile this with [[gsl::Owner]] or gsl::owner<T> somehow so we don't end up with multiple syntaxes in C++? https://reviews.llvm.org/D64448 https://github.com/microsoft/GSL/blob/main/docs/headers.md#g...

If you ask me, the GSL [1] alone is a fairly radical departure from C++ that delivers a lot of safety. I don't know if it's gotten much popularity, though. Probably because it introduces a similar disruption like you might find from a brand new programming language. [1] https://github.com/microsoft/GSL

> With Rust, though, one needs to learn entirely new ideas — things like lifetimes, ownership, and the borrow checker. These are not familiar concepts to most people working in other common languages ... Some of those “new” ideas are, of course, present in other languages — especially functional ones. With C++, lifetime and ownership are just about as important but unfortunately no one's got your back. You can ignore lifetimes and ownership but you do so at your own peril. And the compiler won't tell you you're doing it wrong because the language wasn't designed for it to do so. If you want a taste of rust's "mindset" (with respect to limitations imposed by some types) without jumping ship to a new language, try C++'s Guidelines Support Library [1]. It introduces some of the same benefits/friction as switching to rust but without a ne

That's correct. Also see https://github.com/microsoft/GSL, which is a header-only C++ library that implements the Guidelines Support Library as specified by ISO C++. It's extremely useful (especially to get std::span<T> if you don't have C++20 support) because it provides several constructs to explicitly clarify the _intent_of your code, like `gsl::not_null<T>`, `gsl::narrow_cast<T>()` or `gsl::owner<T>`. `gsl::finally()` is also pretty useful.

A tour of C++ 2nd edition: https://www.stroustrup.com/tour2.html C++ Core Guidelines: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines GSL (Core Guidelines Support Library): https://github.com/Microsoft/GSL

In case someone wants the same in C++, the Guidelines Support Library comes with the class "final_action" and the function "finally()". Check the implementation here: https://github.com/microsoft/GSL/blob/master/include/gsl/gsl.... Example from https://docs.microsoft.com/en-us/cpp/code-quality/c26448?vie...: void poll(connection_info info) { connection c = {}; if (!c.open(info)) return; auto end = gsl::finally([&c] { c.close(); }); while (c.wait()) { connection::header h{}; connection::signature s{}; if (!c.read_header(h)) return; if (!c.read_signature(s)) return; // ... } } I love this pattern, it's a very nice way to have a kind of RAII but with more control and flexibility

C++ has it though, https://github.com/microsoft/GSL/blob/master/include/gsl/spa...

There's also the guideline support library (GSL) -- is anyone using it? https://github.com/Microsoft/GSL Stroustrup talk from 2016: https://www.youtube.com/watch?v=JtMPGwA3MzQ

GSL finally is a lot more ergonomic: #include <utility> // std::move, std::forward // final_action allows you to ensure something gets run at the end of a scope template <class F> class final_action { public: explicit final_action(F f) noexcept : f_(std::move(f)) {} final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_) { other.invoke_ = false; } final_action(const final_action&) = delete; final_action& operator=(const final_action&) = delete; ~final_action() noexcept { if (invoke_) f_(); } private: F f_; bool invoke_ {true}; }; // finally() - convenience function to generate a final_action template <class F> inline final_action<F> finally(const F&

I know that's not directly what you're asking for, but I found the other day that "C++ Core Guidelines" have a helper library "GSL_util" that provide something similar to Go's defer. The implementation is very simple, it's just using a class for its destructor: template <class F> class final_act { public: explicit final_act(F f) noexcept : f_(std::move(f)), invoke_(true) {} final_act(final_act&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_) { other.invoke_ = false; } final_act(const final_act&) = delete; final_act& operator=(const final_act&) = delete; ~final_act() noexcept { if (invoke_) f_(); } private: F f_; bool invoke_; }; Source: https://github.com/microsoft/GSL/blob/ebe7ebfd855a95eb937831...

It's supposed to be part of "Guideline support library", see this section: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppC... The only implementation so far seems to be from Microsoft: https://github.com/Microsoft/GSL/blob/master/include/gsl/gsl...